?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added special handling for the "bbox" line that appears in .lps
[xcircuit.git] / files.c
blob35bba152147dfda5c7f248f35d6502a010b76966
1 /*-----------------------------------------------------------------------*/
2 /* files.c --- file handling routines for xcircuit */
3 /* Copyright (c) 2002 Tim Edwards, Johns Hopkins University */
4 /*-----------------------------------------------------------------------*/
5
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <time.h>
10 #ifndef XC_WIN32
11 #include <pwd.h>
12 #endif
13 #include <ctype.h>
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include <fcntl.h>
17 #ifndef XC_WIN32
18 #include <unistd.h>
19 #include <X11/Intrinsic.h>
20 #include <X11/StringDefs.h>
21 #else
22 #include <winsock2.h>
23 #endif
24
25 #ifdef TCL_WRAPPER
26 #include <tk.h>
27 #else
28 #ifndef XC_WIN32
29 #include "Xw/TextEdit.h" /* for XwTextCopyBuffer() */
30 #endif
31 #endif
32
33 /*------------------------------------------------------------------------*/
34 /* Local includes */
35 /*------------------------------------------------------------------------*/
36
37 #include "colordefs.h"
38 #include "xcircuit.h"
39
40 /*----------------------------------------------------------------------*/
41 /* Function prototype declarations */
42 /*----------------------------------------------------------------------*/
43 #include "prototypes.h"
44
45 #ifdef ASG
46 extern void Route(XCWindowData *, Boolean);
47 extern int ReadSpice(FILE *);
48 #endif
49
50 /*------------------------------------------------------------------------*/
51 /* Useful (local) defines */
52 /*------------------------------------------------------------------------*/
53
54 #define OUTPUTWIDTH 80 /* maximum text width of output */
55
56 #define S_OBLIQUE 13 /* position of Symbol-Oblique in font array */
57
58 #define VEPS 1e-3
59
60 /*------------------------------------------------------------------------*/
61 /* External Variable definitions */
62 /*------------------------------------------------------------------------*/
63
64 #ifdef TCL_WRAPPER
65 extern Tcl_Interp *xcinterp;
66 #endif
67
68 extern char _STR2[250], _STR[150];
69 extern Globaldata xobjs;
70 extern XCWindowData *areawin;
71 extern fontinfo *fonts;
72 extern short fontcount;
73 extern Cursor appcursors[NUM_CURSORS];
74 extern XtAppContext app;
75 extern Display *dpy;
76 extern Window win;
77 extern short beeper;
78 extern int number_colors;
79 extern colorindex *colorlist;
80
81
82 /*------------------------------------------------------*/
83 /* Global variable definitions */
84 /*------------------------------------------------------*/
85
86 Boolean load_in_progress = False;
87 float version;
88
89 /* Structure for remembering what names refer to the same object */
90
91 aliasptr aliastop;
92
93 /*------------------------------------------------------*/
94 /* Simple utility---get rid of newline character */
95 /*------------------------------------------------------*/
96
97 char *ridnewline(char *sptr)
98 {
99 char *tstrp;
100
101 for (tstrp = sptr; *tstrp != '\0' && *tstrp != '\n'; tstrp++);
102 if (*tstrp == '\n') *tstrp = '\0';
103 return tstrp;
104 }
105
106 /*----------------------------------------------------------------------*/
107 /* Check if two filenames are equivalent. This requires separately */
108 /* checking any absolute or relative pathnames in front of the filename */
109 /* as well as the filename itself. */
110 /*----------------------------------------------------------------------*/
111
112 #define PATHSEP '/'
113
114 int filecmp(char *filename1, char *filename2)
115 {
116 char *root1, *root2, *path1, *path2, *end1, *end2;
117 int rval;
118 struct stat statbuf;
119 ino_t inode1;
120 const char *cwdname = ".";
121
122 if (filename1 == NULL || filename2 == NULL) return 1;
123
124 if (!strcmp(filename1, filename2)) return 0; /* exact match */
125
126 root1 = strrchr(filename1, PATHSEP);
127 root2 = strrchr(filename2, PATHSEP);
128
129 if (root1 == NULL) {
130 path1 = (char *)cwdname;
131 end1 = NULL;
132 root1 = filename1;
133 }
134 else {
135 path1 = filename1;
136 end1 = root1;
137 root1++;
138 }
139
140 if (root2 == NULL) {
141 path2 = (char *)cwdname;
142 end2 = NULL;
143 root2 = filename2;
144 }
145 else {
146 path2 = filename2;
147 end2 = root2;
148 root2++;
149 }
150
151 if (strcmp(root1, root2)) return 1; /* root names don't match */
152
153 /* If we got here, one or both filenames specify a directory */
154 /* path, and the directory paths are different strings. */
155 /* However, one may be an absolute path and the other a */
156 /* relative path, so we check the inodes of the paths for */
157 /* equivalence. Note that the file itself is not assumed to */
158 /* exist. */
159
160 rval = 1;
161 if (end1 != NULL) *end1 = '\0';
162 if (stat(path1, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) {
163 inode1 = statbuf.st_ino;
164 if (end2 != NULL) *end2 = '\0';
165 if (stat(path2, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) {
166 if (inode1 == statbuf.st_ino)
167 rval = 0;
168 }
169 if (end2 != NULL) *end2 = PATHSEP;
170 }
171 if (end1 != NULL) *end1 = PATHSEP;
172 return rval;
173 }
174
175 /*--------------------------------------------------------------*/
176 /* Make sure that a string (object or parameter name) is a */
177 /* valid PostScript name. We do this by converting illegal */
178 /* characters to the PostScript \ooo (octal value) form. */
179 /* */
180 /* This routine does not consider whether the name might be a */
181 /* PostScript numeric value. This problem is taken care of by */
182 /* having the load/save routines prepend '@' to parameters and */
183 /* a technology namespace to object names. */
184 /* */
185 /* If "need_prefix" is TRUE, then prepend "@" to the result */
186 /* string, unless teststring is a numerical parameter name */
187 /* (p_...). */
188 /*--------------------------------------------------------------*/
189
190 char *create_valid_psname(char *teststring, Boolean need_prefix)
191 {
192 int i, isize, ssize;
193 static char *optr = NULL;
194 char *sptr, *pptr;
195 Boolean prepend = need_prefix;
196 char illegalchars[] = {'/', '}', '{', ']', '[', ')', '(', '<', '>', ' ', '%'};
197
198 /* Check for illegal characters which have syntactical meaning in */
199 /* PostScript, and the presence of nonprintable characters or */
200 /* whitespace. */
201
202 ssize = strlen(teststring);
203 isize = ssize;
204
205 if (need_prefix && !strncmp(teststring, "p_", 2))
206 prepend = FALSE;
207 else
208 isize++;
209
210 for (sptr = teststring; *sptr != '\0'; sptr++) {
211 if ((!isprint(*sptr)) || isspace(*sptr))
212 isize += 3;
213 else {
214 for (i = 0; i < sizeof(illegalchars); i++) {
215 if (*sptr == illegalchars[i]) {
216 isize += 3;
217 break;
218 }
219 }
220 }
221 }
222 if (isize == ssize) return teststring;
223 isize++;
224
225 if (optr == NULL)
226 optr = (char *)malloc(isize);
227 else
228 optr = (char *)realloc(optr, isize);
229
230 pptr = optr;
231
232 if (prepend) *pptr++ = '@';
233
234 for (sptr = teststring; *sptr != '\0'; sptr++) {
235 if ((!isprint(*sptr)) || isspace(*sptr)) {
236 sprintf(pptr, "\\%03o", *sptr);
237 pptr += 4;
238 }
239 else {
240 for (i = 0; i < sizeof(illegalchars); i++) {
241 if (*sptr == illegalchars[i]) {
242 sprintf(pptr, "\\%03o", *sptr);
243 pptr += 4;
244 break;
245 }
246 }
247 if (i == sizeof(illegalchars))
248 *pptr++ = *sptr;
249 }
250 }
251 *pptr++ = '\0';
252 return optr;
253 }
254
255 /*------------------------------------------------------*/
256 /* Turn a PostScript string with possible backslash */
257 /* escapes into a normal character string. */
258 /* */
259 /* if "spacelegal" is TRUE, we are parsing a PostScript */
260 /* string in parentheses () where whitespace is legal. */
261 /* If FALSE, we are parsing a PostScript name where */
262 /* whitespace is illegal, and any whitespace should be */
263 /* considered the end of the name. */
264 /* */
265 /* "dest" is ASSUMED to be large enough to hold the */
266 /* result. "dest" is always equal to or smaller than */
267 /* "src" in length. "size" should be the maximum size */
268 /* of the string, or 1 less that the allocated memory, */
269 /* allowing for a final NULL byte to be added. */
270 /* */
271 /* The fact that "dest" is always smaller than or equal */
272 /* to "src" means that parse_ps_string(a, a, ...) is */
273 /* legal. */
274 /* */
275 /* Return 0 if the result is empty, 1 otherwise. */
276 /*------------------------------------------------------*/
277
278 int parse_ps_string(char *src, char *dest, int size, Boolean spacelegal, Boolean strip)
279 {
280 char *sptr = src;
281 char *tptr = dest;
282 int tmpdig, rval = 0;
283
284 /* Strip leading "@", inserted by XCircuit to */
285 /* prevent conflicts with PostScript reserved */
286 /* keywords or numbers. */
287
288 if (strip && (*sptr == '@')) sptr++;
289
290 for (;; sptr++) {
291 if ((*sptr == '\0') || (isspace(*sptr) && !spacelegal)) {
292 *tptr = '\0';
293 break;
294 }
295 else {
296 if (*sptr == '\\') {
297 sptr++;
298 if (*sptr >= '0' && *sptr < '8') {
299 sscanf(sptr, "%3o", &tmpdig);
300 *tptr++ = (u_char)tmpdig;
301 sptr += 2;
302 }
303 else
304 *tptr++ = *sptr;
305 }
306 else
307 *tptr++ = *sptr;
308 rval = 1;
309 }
310 if ((int)(tptr - dest) > size) {
311 Wprintf("Warning: Name \"%s\" in input exceeded buffer length!\n", src);
312 *tptr = '\0';
313 return rval;
314 }
315 }
316 return rval;
317 }
318
319 /*------------------------------------------------------*/
320 /* Free memory allocated to a label string */
321 /*------------------------------------------------------*/
322
323 void freelabel(stringpart *string)
324 {
325 stringpart *strptr = string, *tmpptr;
326
327 while (strptr != NULL) {
328 if (strptr->type == TEXT_STRING || strptr->type == PARAM_START)
329 free(strptr->data.string);
330 tmpptr = strptr->nextpart;
331 free(strptr);
332 strptr = tmpptr;
333 }
334 }
335
336 /*------------------------------------------------------*/
337 /* Free memory for a single element */
338 /*------------------------------------------------------*/
339
340 void free_single(genericptr genobj)
341 {
342 objinstptr geninst;
343 oparamptr ops, fops;
344
345 if (IS_POLYGON(genobj)) free(((polyptr)(genobj))->points);
346 else if (IS_LABEL(genobj)) freelabel(((labelptr)(genobj))->string);
347 else if (IS_GRAPHIC(genobj)) freegraphic((graphicptr)(genobj));
348 else if (IS_PATH(genobj)) free(((pathptr)(genobj))->plist);
349 else if (IS_OBJINST(genobj)) {
350 geninst = (objinstptr)genobj;
351 ops = geninst->params;
352 while (ops != NULL) {
353 /* Don't try to free data from indirect parameters */
354 /* (That's not true---all data are copied by epsubstitute) */
355 /* if (find_indirect_param(geninst, ops->key) == NULL) { */
356 switch(ops->type) {
357 case XC_STRING:
358 freelabel(ops->parameter.string);
359 break;
360 case XC_EXPR:
361 free(ops->parameter.expr);
362 break;
363 }
364 /* } */
365 free(ops->key);
366 fops = ops;
367 ops = ops->next;
368 free(fops);
369 }
370 }
371 free_all_eparams(genobj);
372 }
373
374 /*---------------------------------------------------------*/
375 /* Reset an object structure by freeing all alloc'd memory */
376 /*---------------------------------------------------------*/
377
378 void reset(objectptr localdata, short mode)
379 {
380 /* short i; (jdk) */
381
382 if (localdata->polygons != NULL || localdata->labels != NULL)
383 destroynets(localdata);
384
385 localdata->valid = False;
386
387 if (localdata->parts > 0) {
388 genericptr *genobj;
389
390 if (mode != SAVE) {
391
392 for (genobj = localdata->plist; genobj < localdata->plist
393 + localdata->parts; genobj++)
394
395 /* (*genobj == NULL) only on library pages */
396 /* where the instances are kept in the library */
397 /* definition, and are only referenced on the page. */
398
399 if (*genobj != NULL) {
400 free_single(*genobj);
401 free(*genobj);
402 }
403 }
404 free(localdata->plist);
405
406 removeparams(localdata);
407
408 initmem(localdata);
409 if (mode == DESTROY)
410 free(localdata->plist);
411 }
412 }
413
414 /*---------------------------------------------------------*/
415
416 void pagereset(short rpage)
417 {
418 /* free alloc'd filename */
419
420 if (xobjs.pagelist[rpage]->filename != NULL)
421 free(xobjs.pagelist[rpage]->filename);
422 xobjs.pagelist[rpage]->filename = (char *)NULL;
423
424 if (xobjs.pagelist[rpage]->background.name != NULL)
425 free(xobjs.pagelist[rpage]->background.name);
426 xobjs.pagelist[rpage]->background.name = (char *)NULL;
427
428 clearselects();
429
430 /* New pages pick up their properties from page 0, which can be changed */
431 /* from the .xcircuitrc file on startup (or loaded from a script). */
432 /* Thanks to Norman Werner (norman.werner@student.uni-magdeburg.de) for */
433 /* pointing out this more obvious way of doing the reset, and providing */
434 /* a patch. */
435
436 xobjs.pagelist[rpage]->wirewidth = xobjs.pagelist[0]->wirewidth;
437 xobjs.pagelist[rpage]->orient = xobjs.pagelist[0]->orient;
438 xobjs.pagelist[rpage]->pmode = xobjs.pagelist[0]->pmode;
439 xobjs.pagelist[rpage]->outscale = xobjs.pagelist[0]->outscale;
440 xobjs.pagelist[rpage]->drawingscale.x = xobjs.pagelist[0]->drawingscale.x;
441 xobjs.pagelist[rpage]->drawingscale.y = xobjs.pagelist[0]->drawingscale.y;
442 xobjs.pagelist[rpage]->gridspace = xobjs.pagelist[0]->gridspace;
443 xobjs.pagelist[rpage]->snapspace = xobjs.pagelist[0]->snapspace;
444 xobjs.pagelist[rpage]->coordstyle = xobjs.pagelist[0]->coordstyle;
445 xobjs.pagelist[rpage]->margins = xobjs.pagelist[0]->margins;
446
447 if (xobjs.pagelist[rpage]->coordstyle == CM) {
448 xobjs.pagelist[rpage]->pagesize.x = 595;
449 xobjs.pagelist[rpage]->pagesize.y = 842; /* A4 */
450 }
451 else {
452 xobjs.pagelist[rpage]->pagesize.x = 612; /* letter */
453 xobjs.pagelist[rpage]->pagesize.y = 792;
454 }
455 }
456
457 /*---------------------------------------------------------*/
458
459 void initmem(objectptr localdata)
460 {
461 localdata->parts = 0;
462 localdata->plist = (genericptr *)malloc(sizeof(genericptr));
463 localdata->hidden = False;
464 localdata->changes = 0;
465 localdata->params = NULL;
466
467 localdata->viewscale = 0.5;
468
469 /* Object should not reference the window: this needs to be rethunk! */
470 if (areawin != NULL) {
471 localdata->pcorner.x = -areawin->width;
472 localdata->pcorner.y = -areawin->height;
473 }
474 localdata->bbox.width = 0;
475 localdata->bbox.height = 0;
476 localdata->bbox.lowerleft.x = 0;
477 localdata->bbox.lowerleft.y = 0;
478
479 localdata->highlight.netlist = NULL;
480 localdata->highlight.thisinst = NULL;
481 localdata->schemtype = PRIMARY;
482 localdata->symschem = NULL;
483 localdata->netnames = NULL;
484 localdata->polygons = NULL;
485 localdata->labels = NULL;
486 localdata->ports = NULL;
487 localdata->calls = NULL;
488 localdata->valid = False;
489 localdata->infolabels = False;
490 localdata->traversed = False;
491 }
492
493 /*--------------------------------------------------------------*/
494 /* Exhaustively compare the contents of two objects and return */
495 /* true if equivalent, false if not. */
496 /*--------------------------------------------------------------*/
497
498 Boolean elemcompare(genericptr *compgen, genericptr *gchk)
499 {
500 Boolean bres;
501 switch(ELEMENTTYPE(*compgen)) {
502 case(ARC):
503 bres = (TOARC(compgen)->position.x == TOARC(gchk)->position.x &&
504 TOARC(compgen)->position.y == TOARC(gchk)->position.y &&
505 TOARC(compgen)->style == TOARC(gchk)->style &&
506 TOARC(compgen)->width == TOARC(gchk)->width &&
507 abs(TOARC(compgen)->radius) == abs(TOARC(gchk)->radius) &&
508 TOARC(compgen)->yaxis == TOARC(gchk)->yaxis &&
509 TOARC(compgen)->angle1 == TOARC(gchk)->angle1 &&
510 TOARC(compgen)->angle2 == TOARC(gchk)->angle2);
511 break;
512 case(SPLINE):
513 bres = (TOSPLINE(compgen)->style == TOSPLINE(gchk)->style &&
514 TOSPLINE(compgen)->width == TOSPLINE(gchk)->width &&
515 TOSPLINE(compgen)->ctrl[0].x == TOSPLINE(gchk)->ctrl[0].x &&
516 TOSPLINE(compgen)->ctrl[0].y == TOSPLINE(gchk)->ctrl[0].y &&
517 TOSPLINE(compgen)->ctrl[1].x == TOSPLINE(gchk)->ctrl[1].x &&
518 TOSPLINE(compgen)->ctrl[1].y == TOSPLINE(gchk)->ctrl[1].y &&
519 TOSPLINE(compgen)->ctrl[2].x == TOSPLINE(gchk)->ctrl[2].x &&
520 TOSPLINE(compgen)->ctrl[2].y == TOSPLINE(gchk)->ctrl[2].y &&
521 TOSPLINE(compgen)->ctrl[3].x == TOSPLINE(gchk)->ctrl[3].x &&
522 TOSPLINE(compgen)->ctrl[3].y == TOSPLINE(gchk)->ctrl[3].y);
523 break;
524 case(POLYGON): {
525 int i;
526 if (TOPOLY(compgen)->style == TOPOLY(gchk)->style &&
527 TOPOLY(compgen)->width == TOPOLY(gchk)->width &&
528 TOPOLY(compgen)->number == TOPOLY(gchk)->number) {
529 for (i = 0; i < TOPOLY(compgen)->number; i++) {
530 if (TOPOLY(compgen)->points[i].x != TOPOLY(gchk)->points[i].x
531 || TOPOLY(compgen)->points[i].y != TOPOLY(gchk)->points[i].y)
532 break;
533 }
534 bres = (i == TOPOLY(compgen)->number);
535 }
536 else bres = False;
537 }break;
538 }
539 return bres;
540 }
541
542 /*--------------------------------------------------------------*/
543 /* Compare any element with any other element. */
544 /*--------------------------------------------------------------*/
545
546 Boolean compare_single(genericptr *compgen, genericptr *gchk)
547 {
548 Boolean bres = False;
549
550 if ((*gchk)->type == (*compgen)->type) {
551 switch(ELEMENTTYPE(*compgen)) {
552 case(OBJINST):{
553 objinst *newobj = TOOBJINST(compgen);
554 objinst *oldobj = TOOBJINST(gchk);
555 bres = (newobj->position.x == oldobj->position.x &&
556 newobj->position.y == oldobj->position.y &&
557 newobj->rotation == oldobj->rotation &&
558 newobj->scale == oldobj->scale &&
559 newobj->style == oldobj->style &&
560 newobj->thisobject == oldobj->thisobject);
561 } break;
562 case(LABEL):
563 bres = (TOLABEL(compgen)->position.x == TOLABEL(gchk)->position.x &&
564 TOLABEL(compgen)->position.y == TOLABEL(gchk)->position.y &&
565 TOLABEL(compgen)->rotation == TOLABEL(gchk)->rotation &&
566 TOLABEL(compgen)->scale == TOLABEL(gchk)->scale &&
567 TOLABEL(compgen)->anchor == TOLABEL(gchk)->anchor &&
568 TOLABEL(compgen)->pin == TOLABEL(gchk)->pin &&
569 !stringcomp(TOLABEL(compgen)->string, TOLABEL(gchk)->string));
570 break;
571 case(PATH): /* elements *must* be in same order for a path */
572 bres = (TOPATH(compgen)->parts == TOPATH(gchk)->parts &&
573 TOPATH(compgen)->style == TOPATH(gchk)->style &&
574 TOPATH(compgen)->width == TOPATH(gchk)->width);
575 if (bres) {
576 genericptr *pathchk, *gpath;
577 for (pathchk = TOPATH(compgen)->plist, gpath =
578 TOPATH(gchk)->plist; pathchk < TOPATH(compgen)->plist
579 + TOPATH(compgen)->parts; pathchk++, gpath++) {
580 if (!elemcompare(pathchk, gpath)) bres = False;
581 }
582 }
583 break;
584 case(ARC): case(SPLINE): case(POLYGON):
585 bres = elemcompare(compgen, gchk);
586 break;
587 }
588 }
589 return bres;
590 }
591
592 /*--------------------------------------------------------------------*/
593
594 short objcompare(objectptr obja, objectptr objb)
595 {
596 genericptr *compgen, *glist, *gchk, *remg;
597 short csize;
598 Boolean bres;
599
600 /* quick check on equivalence of number of objects */
601
602 if (obja->parts != objb->parts) return False;
603
604 /* check equivalence of parameters. Parameters need not be in any */
605 /* order; they must only match by key and value. */
606
607 if (obja->params == NULL && objb->params != NULL) return False;
608 else if (obja->params != NULL && objb->params == NULL) return False;
609 else if (obja->params != NULL || objb->params != NULL) {
610 oparamptr opsa, opsb;
611 for (opsa = obja->params; opsa != NULL; opsa = opsa->next) {
612 opsb = match_param(objb, opsa->key);
613 if (opsb == NULL) return False;
614 else if (opsa->type != opsb->type) return False;
615 switch (opsa->type) {
616 case XC_STRING:
617 if (stringcomp(opsa->parameter.string, opsb->parameter.string))
618 return False;
619 break;
620 case XC_EXPR:
621 if (strcmp(opsa->parameter.expr, opsb->parameter.expr))
622 return False;
623 break;
624 case XC_INT: case XC_FLOAT:
625 if (opsa->parameter.ivalue != opsb->parameter.ivalue)
626 return False;
627 break;
628 }
629 }
630 }
631
632 /* For the exhaustive check we must match component for component. */
633 /* Best not to assume that elements are in same order for both. */
634
635 csize = obja->parts;
636
637 glist = (genericptr *)malloc(csize * sizeof(genericptr));
638 for (compgen = objb->plist; compgen < objb->plist + csize; compgen++)
639 (*(glist + (int)(compgen - objb->plist))) = *compgen;
640 for (compgen = obja->plist; compgen < obja->plist + obja->parts;
641 compgen++) {
642 bres = False;
643 for (gchk = glist; gchk < glist + csize; gchk++) {
644 if ((*compgen)->color == (*gchk)->color)
645 bres = compare_single(compgen, gchk);
646 if (bres) {
647 csize--;
648 for (remg = gchk; remg < glist + csize; remg++)
649 *remg = *(remg + 1);
650 break;
651 }
652 }
653 }
654 free(glist);
655 if (csize != 0) return False;
656
657 /* Both objects cannot attempt to set an associated schematic/symbol to */
658 /* separate objects, although it is okay for one to make the association */
659 /* and the other not to. */
660
661 if (obja->symschem != NULL && objb->symschem != NULL)
662 if (obja->symschem != objb->symschem)
663 return False;
664
665 return(True);
666 }
667
668 /*------------------------*/
669 /* scale renormalization */
670 /*------------------------*/
671
672 float getpsscale(float value, short page)
673 {
674 if (xobjs.pagelist[page]->coordstyle != CM)
675 return (value * INCHSCALE);
676 else
677 return (value * CMSCALE);
678 }
679
680 /*---------------------------------------------------------------*/
681 /* Keep track of columns of output and split lines when too long */
682 /*---------------------------------------------------------------*/
683
684 void dostcount(FILE *ps, short *count, short addlength)
685 {
686 *count += addlength;
687 if (*count > OUTPUTWIDTH) {
688 *count = addlength;
689 fprintf(ps, "\n");
690 }
691 }
692
693 /*----------------------------------------------------------------------*/
694 /* Write a numerical value as a string to _STR, making a parameter */
695 /* substitution if appropriate. */
696 /* Return 1 if a parameter substitution was made, 0 if not. */
697 /*----------------------------------------------------------------------*/
698
699 Boolean varpcheck(FILE *ps, short value, objectptr localdata, int pointno,
700 short *stptr, genericptr thiselem, u_char which)
701 {
702 oparamptr ops;
703 eparamptr epp;
704 Boolean done = False;
705
706 for (epp = thiselem->passed; epp != NULL; epp = epp->next) {
707 if ((epp->pdata.pointno != -1) && (epp->pdata.pointno != pointno)) continue;
708 ops = match_param(localdata, epp->key);
709 if (ops != NULL && (ops->which == which)) {
710 sprintf(_STR, "%s ", epp->key);
711 done = True;
712 break;
713 }
714 }
715
716 if (!done) {
717 if (pointno == -1) return done;
718 sprintf(_STR, "%d ", (int)value);
719 }
720 else if ((epp->pdata.pointno == -1) && (pointno >= 0)) {
721 sprintf(_STR, "%d ", (int)value - ops->parameter.ivalue);
722 }
723
724 dostcount (ps, stptr, strlen(_STR));
725 fputs(_STR, ps);
726 return done;
727 }
728
729 /*----------------------------------------------------------------------*/
730 /* like varpcheck(), but without pointnumber */
731 /*----------------------------------------------------------------------*/
732
733 void varcheck(FILE *ps, short value, objectptr localdata,
734 short *stptr, genericptr thiselem, u_char which)
735 {
736 varpcheck(ps, value, localdata, 0, stptr, thiselem, which);
737 }
738
739 /*----------------------------------------------------------------------*/
740 /* like varcheck(), but for floating-point values */
741 /*----------------------------------------------------------------------*/
742
743 void varfcheck(FILE *ps, float value, objectptr localdata, short *stptr,
744 genericptr thiselem, u_char which)
745 {
746 oparamptr ops;
747 eparamptr epp;
748 Boolean done = False;
749
750 for (epp = thiselem->passed; epp != NULL; epp = epp->next) {
751 ops = match_param(localdata, epp->key);
752 if (ops != NULL && (ops->which == which)) {
753 sprintf(_STR, "%s ", epp->key);
754 done = True;
755 break;
756 }
757 }
758
759 if (!done)
760 sprintf(_STR, "%3.3f ", value);
761
762 dostcount (ps, stptr, strlen(_STR));
763 fputs(_STR, ps);
764 }
765
766 /*----------------------------------------------------------------------*/
767 /* Like varpcheck(), for path types only. */
768 /*----------------------------------------------------------------------*/
769
770 Boolean varpathcheck(FILE *ps, short value, objectptr localdata, int pointno,
771 short *stptr, genericptr *thiselem, pathptr thispath, u_char which)
772 {
773 oparamptr ops;
774 eparamptr epp;
775 Boolean done = False;
776
777 for (epp = thispath->passed; epp != NULL; epp = epp->next) {
778 if ((epp->pdata.pathpt[0] != -1) && (epp->pdata.pathpt[1] != pointno)) continue;
779 if ((epp->pdata.pathpt[0] != -1) && (epp->pdata.pathpt[0] !=
780 (short)(thiselem - thispath->plist))) continue;
781 ops = match_param(localdata, epp->key);
782 if (ops != NULL && (ops->which == which)) {
783 sprintf(_STR, "%s ", epp->key);
784 done = True;
785 break;
786 }
787 }
788
789 if (!done) {
790 if (pointno == -1) return done;
791 sprintf(_STR, "%d ", (int)value);
792 }
793 else if ((epp->pdata.pathpt[0] == -1) && (pointno >= 0)) {
794 sprintf(_STR, "%d ", (int)value - ops->parameter.ivalue);
795 }
796 dostcount (ps, stptr, strlen(_STR));
797 fputs(_STR, ps);
798 return done;
799 }
800
801 /* Structure used to hold data specific to each load mode. See */
802 /* xcircuit.h for the list of load modes (enum loadmodes) */
803
804 typedef struct _loaddata {
805 void (*func)(); /* Routine to run to load the file */
806 char *prompt; /* Substring name of action, for prompting */
807 char *filext; /* Default extention of file to load */
808 } loaddata;
809
810 /*-------------------------------------------------------*/
811 /* Load a PostScript or Python (interpreter script) file */
812 /*-------------------------------------------------------*/
813
814 void getfile(xcWidget button, pointertype mode, caddr_t nulldata)
815 {
816 static loaddata loadmodes[LOAD_MODES] = {
817 {normalloadfile, "load", "ps"}, /* mode NORMAL */
818 {importfile, "import", "ps"}, /* mode IMPORT */
819 {loadbackground, "render", "ps"}, /* mode PSBKGROUND */
820 #ifdef HAVE_PYTHON
821 {execscript, "execute", "py"},
822 #else
823 {execscript, "execute", ""}, /* mode SCRIPT */
824 #endif
825 {crashrecover, "recover", "ps"}, /* mode RECOVER */
826 #ifdef ASG
827 {importspice, "import", "spice"}, /* mode IMPORTSPICE */
828 #endif
829 #ifdef HAVE_CAIRO
830 {importgraphic, "import", "ppm"}, /* mode IMPORTGRAPHIC */
831 #endif
832 };
833
834 buttonsave *savebutton = NULL;
835 char *promptstr = NULL;
836 /* char strext[10]; (jdk) */
837 int idx = (int)mode;
838
839 if (is_page(topobject) == -1) {
840 Wprintf("Can only read file into top-level page!");
841 return;
842 }
843 else if (idx >= LOAD_MODES) {
844 Wprintf("Unknown mode passed to routine getfile()\n");
845 return;
846 }
847 #ifndef TCL_WRAPPER
848 savebutton = getgeneric(button, getfile, (void *)mode);
849 #endif
850 if (idx == RECOVER) {
851 char *cfile = getcrashfilename();
852 promptstr = (char *)malloc(18 + ((cfile == NULL) ? 9 : strlen(cfile)));
853 sprintf(promptstr, "Recover file \'%s\'?", (cfile == NULL) ? "(unknown)" : cfile);
854 popupprompt(button, promptstr, NULL, loadmodes[idx].func, savebutton, NULL);
855 if (cfile) free(cfile);
856 }
857 else {
858 promptstr = (char *)malloc(18 + strlen(loadmodes[idx].prompt));
859 sprintf(promptstr, "Select file to %s:", loadmodes[idx].prompt);
860 popupprompt(button, promptstr, "\0", loadmodes[idx].func,
861 savebutton, loadmodes[idx].filext);
862 }
863 free(promptstr);
864 }
865
866 /*--------------------------------------------------------------*/
867 /* Tilde ('~') expansion in file name. Assumes that filename */
868 /* is a static character array of size "nchars". */
869 /*--------------------------------------------------------------*/
870
871 Boolean xc_tilde_expand(char *filename, int nchars)
872 {
873 #ifndef _MSC_VER
874 struct passwd *passwd;
875 char *username = NULL, *expanded, *sptr;
876
877 if (*filename == '~') {
878 sptr = filename + 1;
879 if (*sptr == '/' || *sptr == ' ' || *sptr == '\0')
880 username = getenv("HOME");
881 else {
882 for (; *sptr != '/' && *sptr != '\0'; sptr++);
883 if (*sptr == '\0') *(sptr + 1) = '\0';
884 *sptr = '\0';
885
886 passwd = getpwnam(filename + 1);
887 if (passwd != NULL)
888 username = passwd->pw_dir;
889
890 *sptr = '/';
891 }
892 if (username != NULL) {
893 expanded = (char *)malloc(strlen(username) +
894 strlen(filename));
895 strcpy(expanded, username);
896 strcat(expanded, sptr);
897 strncpy(filename, expanded, nchars);
898 free(expanded);
899 }
900 return True;
901 }
902 return False;
903 #else
904 return False;
905 #endif
906 }
907
908 /*--------------------------------------------------------------*/
909 /* Variable ('$') expansion in file name */
910 /*--------------------------------------------------------------*/
911
912 Boolean xc_variable_expand(char *filename, int nchars)
913 {
914 char *expanded, *sptr, tmpchar, *varpos, *varsub;
915
916 if ((varpos = strchr(filename, '$')) != NULL) {
917 for (sptr = varpos; *sptr != '/' && *sptr != '\0'; sptr++);
918 if (*sptr == '\0') *(sptr + 1) = '\0';
919 tmpchar = *sptr;
920 *sptr = '\0';
921
922 #ifdef TCL_WRAPPER
923 /* Interpret as a Tcl variable */
924 varsub = (char *)Tcl_GetVar(xcinterp, varpos + 1, TCL_NAMESPACE_ONLY);
925 #else
926 /* Interpret as an environment variable */
927 varsub = (char *)getenv((const char *)(varpos + 1));
928 #endif
929
930 if (varsub != NULL) {
931
932 *varpos = '\0';
933 expanded = (char *)malloc(strlen(varsub) + strlen(filename) +
934 strlen(sptr + 1) + 2);
935 strcpy(expanded, filename);
936 strcat(expanded, varsub);
937 *sptr = tmpchar;
938 strcat(expanded, sptr);
939 strncpy(filename, expanded, nchars);
940 free(expanded);
941 }
942 else
943 *sptr = tmpchar;
944 return True;
945 }
946 return False;
947 }
948
949 /*--------------------------------------------------------------*/
950 /* Attempt to find a file and open it. */
951 /*--------------------------------------------------------------*/
952
953 FILE *fileopen(char *filename, char *suffix, char *name_return, int nchars)
954 {
955 FILE *file = NULL;
956 char inname[250], expname[250], *sptr, *cptr, *iptr, *froot;
957 int slen;
958
959 sscanf(filename, "%249s", expname);
960 xc_tilde_expand(expname, 249);
961 while (xc_variable_expand(expname, 249));
962
963 sptr = xobjs.filesearchpath;
964 while (1) {
965 if ((xobjs.filesearchpath == NULL) || (expname[0] == '/')) {
966 strcpy(inname, expname);
967 iptr = inname;
968 }
969 else {
970 strcpy(inname, sptr);
971 cptr = strchr(sptr, ':');
972 slen = (cptr == NULL) ? strlen(sptr) : (int)(cptr - sptr);
973 sptr += (slen + ((cptr == NULL) ? 0 : 1));
974 iptr = inname + slen;
975 if (*(iptr - 1) != '/') strcpy(iptr++, "/");
976 strcpy(iptr, expname);
977 }
978
979 /* Attempt to open the filename with a suffix */
980
981 if ((froot = strrchr(iptr, '/')) == NULL) froot = iptr;
982 if (strrchr(froot, '.') == NULL) {
983 if (suffix) {
984 if (suffix[0] != '.')
985 strncat(inname, ".", 249);
986 strncat(inname, suffix, 249);
987 }
988 file = fopen(inname, "r");
989 }
990
991 /* Attempt to open the filename as given, without a suffix */
992
993 if (file == NULL) {
994 strcpy(iptr, expname);
995 file = fopen(inname, "r");
996 }
997
998 if (file != NULL) break;
999 else if (sptr == NULL) break;
1000 else if (*sptr == '\0') break;
1001 }
1002
1003 if (name_return) strncpy(name_return, inname, nchars);
1004 return file;
1005 }
1006
1007 /*---------------------------------------------------------*/
1008
1009 Boolean nextfilename() /* extract next filename from _STR2 into _STR */
1010 {
1011 char *cptr, *slptr;
1012
1013 sprintf(_STR, "%.149s", _STR2);
1014 if ((cptr = strrchr(_STR2, ',')) != NULL) {
1015 slptr = strrchr(_STR, '/');
1016 if (slptr == NULL || ((slptr - _STR) > (cptr - _STR2))) slptr = _STR - 1;
1017 sprintf(slptr + 1, "%s", cptr + 1);
1018 *cptr = '\0';
1019 return True;
1020 }
1021 else return False;
1022 }
1023
1024 /*---------------------------------------------------------*/
1025
1026 void loadfontlib()
1027 {
1028 loadlibrary(FONTLIB);
1029 }
1030
1031 /*------------------------------------------------------*/
1032 /* Handle library loading and refresh current page if */
1033 /* it is a library page that just changed. */
1034 /*------------------------------------------------------*/
1035
1036 void loadglib(Boolean lflag, short ilib, short tlib)
1037 {
1038 while (nextfilename()) {
1039 if (lflag)
1040 lflag = False;
1041 else
1042 ilib = createlibrary(False);
1043 loadlibrary(ilib);
1044 /* if (ilib == tlib) zoomview(NULL, NULL, NULL); */
1045 }
1046 if (lflag)
1047 lflag = False;
1048 else
1049 ilib = createlibrary(False);
1050 loadlibrary(ilib);
1051 /* if (ilib == tlib) zoomview(NULL, NULL, NULL); */
1052 }
1053
1054 /*------------------------------------------------------*/
1055 /* Load new library: Create new library page and load */
1056 /* to it. */
1057 /*------------------------------------------------------*/
1058
1059 void loadulib()
1060 {
1061 loadglib(False, (short)0, (short)is_library(topobject) + LIBRARY);
1062 }
1063
1064 /*-----------------------------------------------------------*/
1065 /* Add to library: If on library page, add to that library. */
1066 /* Otherwise, create a new library page and load to it. */
1067 /*-----------------------------------------------------------*/
1068
1069 void loadblib()
1070 {
1071 short ilib, tlib;
1072 Boolean lflag = True;
1073
1074 /* Flag whether current page is a library page or not */
1075
1076 if ((tlib = is_library(topobject)) < 0) {
1077 ilib = LIBRARY;
1078 lflag = False;
1079 }
1080 else
1081 ilib = tlib + LIBRARY;
1082
1083 loadglib(lflag, ilib, tlib + LIBRARY);
1084 }
1085
1086 /*---------------------------------------------------------*/
1087
1088 void getlib(xcWidget button, caddr_t clientdata, caddr_t nulldata)
1089 {
1090 buttonsave *savebutton;
1091 #ifndef TCL_WRAPPER
1092 savebutton = getgeneric(button, getlib, NULL);
1093 #endif
1094 popupprompt(button, "Enter library to load:", "\0", loadblib, savebutton,
1095 "lps");
1096 }
1097
1098 /*---------------------------------------------------------*/
1099
1100 void getuserlib(xcWidget button, caddr_t clientdata, caddr_t nulldata)
1101 {
1102 buttonsave *savebutton;
1103
1104 #ifndef TCL_WRAPPER
1105 savebutton = getgeneric(button, getuserlib, NULL);
1106 #endif
1107 popupprompt(button, "Enter library to load:", "\0", loadulib, savebutton,
1108 "lps");
1109 }
1110
1111 /*------------------------------------------------------*/
1112 /* Add a new name to the list of aliases for an object */
1113 /*------------------------------------------------------*/
1114
1115 Boolean addalias(objectptr thisobj, char *newname)
1116 {
1117 aliasptr aref;
1118 slistptr sref;
1119 /* Boolean retval = False; (jdk) */
1120 char *origname = thisobj->name;
1121
1122 for (aref = aliastop; aref != NULL; aref = aref->next)
1123 if (aref->baseobj == thisobj)
1124 break;
1125
1126 /* An equivalence, not an alias */
1127 if (!strcmp(origname, newname)) return True;
1128
1129 if (aref == NULL) { /* entry does not exist; add new baseobj */
1130 aref = (aliasptr)malloc(sizeof(alias));
1131 aref->baseobj = thisobj;
1132 aref->aliases = NULL;
1133 aref->next = aliastop;
1134 aliastop = aref;
1135 }
1136
1137 for (sref = aref->aliases; sref != NULL; sref = sref->next)
1138 if (!strcmp(sref->alias, newname))
1139 break;
1140
1141 if (sref == NULL) { /* needs new entry */
1142 sref = (slistptr)malloc(sizeof(stringlist));
1143 sref->alias = strdup(newname);
1144 sref->next = aref->aliases;
1145 aref->aliases = sref;
1146 return False;
1147 }
1148 else return True; /* alias already exists! */
1149 }
1150
1151 /*------------------------------------------------------*/
1152 /* Remove all object name aliases */
1153 /*------------------------------------------------------*/
1154
1155 void cleanupaliases(short mode)
1156 {
1157 aliasptr aref;
1158 slistptr sref;
1159 objectptr baseobj;
1160 char *sptr; /* *basename, (jdk) */
1161 int i, j;
1162
1163 if (aliastop == NULL) return;
1164
1165 for (aref = aliastop; aref != NULL; aref = aref->next) {
1166 baseobj = aref->baseobj;
1167 for (sref = aref->aliases; sref != NULL; sref = sref->next)
1168 free(sref->alias);
1169 }
1170
1171 for (; (aref = aliastop->next); aliastop = aref)
1172 free(aliastop);
1173 free(aliastop);
1174 aliastop = NULL;
1175
1176 /* Get rid of propagating underscores in names */
1177
1178 for (i = 0; i < ((mode == FONTLIB) ? 1 : xobjs.numlibs); i++) {
1179 for (j = 0; j < ((mode == FONTLIB) ? xobjs.fontlib.number :
1180 xobjs.userlibs[i].number); j++) {
1181 baseobj = (mode == FONTLIB) ? *(xobjs.fontlib.library + j) :
1182 *(xobjs.userlibs[i].library + j);
1183
1184 sptr = baseobj->name;
1185 while (*sptr == '_') sptr++;
1186 /* need memmove to avoid overwriting? */
1187 memmove((void *)baseobj->name, (const void *)sptr, strlen(sptr) + 1);
1188 checkname(baseobj);
1189 }
1190 }
1191 }
1192
1193 /*------------------------------------------------------*/
1194 /* Open a library file by name and return a pointer to */
1195 /* the file structure, or NULL if an error occurred. */
1196 /*------------------------------------------------------*/
1197
1198 FILE *libopen(char *libname, short mode, char *name_return, int nchars)
1199 {
1200 FILE *file = NULL;
1201 char inname[150], expname[150], *sptr, *cptr, *iptr;
1202 int slen;
1203 char *suffix = (mode == FONTENCODING) ? ".xfe" : ".lps";
1204
1205 sscanf(libname, "%149s", expname);
1206 xc_tilde_expand(expname, 149);
1207 while(xc_variable_expand(expname, 149));
1208
1209 sptr = xobjs.libsearchpath;
1210 while (1) {
1211
1212 if ((xobjs.libsearchpath == NULL) || (expname[0] == '/')) {
1213 strcpy(inname, expname);
1214 iptr = inname;
1215 }
1216 else {
1217 strcpy(inname, sptr);
1218 cptr = strchr(sptr, ':');
1219 slen = (cptr == NULL) ? strlen(sptr) : (int)(cptr - sptr);
1220 sptr += (slen + ((cptr == NULL) ? 0 : 1));
1221 iptr = inname + slen;
1222 if (*(iptr - 1) != '/') strcpy(iptr++, "/");
1223 strcpy(iptr, expname);
1224 }
1225
1226 /* Try to open the filename with a suffix if it doesn't have one */
1227
1228 if (strrchr(iptr, '.') == NULL) {
1229 strncat(inname, suffix, 149);
1230 file = fopen(inname, "r");
1231 }
1232
1233 /* Try to open the filename as given, without a suffix */
1234
1235 if (file == NULL) {
1236 strcpy(iptr, expname);
1237 file = fopen(inname, "r");
1238 }
1239
1240 if (file != NULL) break;
1241 else if (sptr == NULL) break;
1242 else if (*sptr == '\0') break;
1243 }
1244
1245 if ((file == NULL) && (xobjs.libsearchpath == NULL)) {
1246
1247 /* if not found in cwd and there is no library search */
1248 /* path, look for environment variable "XCIRCUIT_LIB_DIR" */
1249 /* defined (Thanks to Ali Moini, U. Adelaide, S. Australia) */
1250
1251 char *tmp_s = getenv((const char *)"XCIRCUIT_LIB_DIR");
1252
1253 if (tmp_s != NULL) {
1254 sprintf(inname, "%s/%s", tmp_s, expname);
1255 file = fopen(inname, "r");
1256 if (file == NULL) {
1257 sprintf(inname, "%s/%s%s", tmp_s, expname, suffix);
1258 file = fopen(inname, "r");
1259 }
1260 }
1261
1262 /* last resort: hard-coded directory BUILTINS_DIR */
1263
1264 if (file == NULL) {
1265 sprintf(inname, "%s/%s", BUILTINS_DIR, expname);
1266 file = fopen(inname, "r");
1267 if (file == NULL) {
1268 sprintf(inname, "%s/%s%s", BUILTINS_DIR, expname, suffix);
1269 file = fopen(inname, "r");
1270 }
1271 }
1272 }
1273
1274 if (name_return) strncpy(name_return, inname, nchars);
1275 return file;
1276 }
1277
1278 /*--------------------------------------------------------------*/
1279 /* Add a record to the instlist list of the library indexed by */
1280 /* mode, create a new instance, and add it to the record. */
1281 /* */
1282 /* objname is the name of the library object to be instanced, */
1283 /* and buffer is the line containing the instance parameters */
1284 /* of the new instance, optionally preceded by scale and */
1285 /* rotation values. */
1286 /* */
1287 /*--------------------------------------------------------------*/
1288
1289 objinstptr new_library_instance(short mode, char *objname, char *buffer,
1290 TechPtr defaulttech)
1291 {
1292 char *lineptr;
1293 objectptr libobj, localdata;
1294 objinstptr newobjinst;
1295 int j;
1296 char *nsptr, *fullname = objname;
1297
1298 localdata = xobjs.libtop[mode + LIBRARY]->thisobject;
1299
1300 /* For (older) libraries that do not use technologies, give the */
1301 /* object a technology name in the form <library>::<object> */
1302
1303 if ((nsptr = strstr(objname, "::")) == NULL) {
1304 int deftechlen = (defaulttech == NULL) ? 0 : strlen(defaulttech->technology);
1305 fullname = (char *)malloc(deftechlen + strlen(objname) + 3);
1306 if (defaulttech == NULL)
1307 sprintf(fullname, "::%s", objname);
1308 else
1309 sprintf(fullname, "%s::%s", defaulttech->technology, objname);
1310 }
1311
1312 for (j = 0; j < xobjs.userlibs[mode].number; j++) {
1313 libobj = *(xobjs.userlibs[mode].library + j);
1314 if (!strcmp(fullname, libobj->name)) {
1315 newobjinst = addtoinstlist(mode, libobj, TRUE);
1316
1317 lineptr = buffer;
1318 while (isspace(*lineptr)) lineptr++;
1319 if (*lineptr != '<') {
1320 /* May declare instanced scale and rotation first */
1321 lineptr = varfscan(localdata, lineptr, &newobjinst->scale,
1322 (genericptr)newobjinst, P_SCALE);
1323 lineptr = varfscan(localdata, lineptr, &newobjinst->rotation,
1324 (genericptr)newobjinst, P_ROTATION);
1325 }
1326 readparams(NULL, newobjinst, libobj, lineptr);
1327 if (fullname != objname) free(fullname);
1328 return newobjinst;
1329 }
1330 }
1331 if (fullname != objname) free(fullname);
1332 return NULL; /* error finding the library object */
1333 }
1334
1335 /*------------------------------------------------------*/
1336 /* Import a single object from a library file. "mode" */
1337 /* is the number of the library into which the object */
1338 /* will be placed. This function allows new libraries */
1339 /* to be generated by "cutting and pasting" from */
1340 /* existing libraries. It also allows better library */
1341 /* management when the number of objects becomes very */
1342 /* large, such as when using "diplib" (7400 series */
1343 /* chips, created from the PCB library). */
1344 /*------------------------------------------------------*/
1345
1346 void importfromlibrary(short mode, char *libname, char *objname)
1347 {
1348 FILE *ps;
1349 char temp[150], keyword[100];
1350 char inname[150], *tptr;
1351 objectptr *newobject;
1352 objlistptr redef;
1353 float saveversion;
1354 Boolean dependencies = False;
1355 TechPtr nsptr = NULL;
1356
1357 ps = libopen(libname, mode, inname, 149);
1358 if (ps == NULL) {
1359 Fprintf(stderr, "Cannot open library %s for import.\n", libname);
1360 return;
1361 }
1362
1363 version = 2.0; /* Assume version is 2.0 unless found in header */
1364
1365 for(;;) {
1366 if (fgets(temp, 149, ps) == NULL) {
1367 Wprintf("Error in library.");
1368 goto endload;
1369 }
1370 else if (temp[0] == '/') {
1371 int s = 1;
1372 if (temp[1] == '@') s = 2;
1373 sscanf(&temp[s], "%s", keyword);
1374 if (!strcmp(keyword, objname))
1375 break;
1376 }
1377 else if (*temp == '%') {
1378 char *tptr = temp + 1;
1379 while (isspace(*tptr)) tptr++;
1380 if (!strncmp(tptr, "Version:", 8)) {
1381 float tmpv;
1382 tptr += 9;
1383 if (sscanf(tptr, "%f", &tmpv) > 0) version = tmpv;
1384 }
1385 else if (!strncmp(tptr, "Library", 7)) {
1386 char *techname = strstr(tptr, ":");
1387 if (techname != NULL) {
1388 techname++; /* skip over colon */
1389 while(isspace(*techname)) techname++;
1390 ridnewline(techname); /* Remove newline character */
1391 if ((tptr = strrchr(techname, '/')) != NULL)
1392 techname = tptr + 1;
1393 if ((tptr = strrchr(techname, '.')) != NULL)
1394 if (!strncmp(tptr, ".lps", 4))
1395 *tptr = '\0';
1396 nsptr = AddNewTechnology(techname, inname);
1397 if (nsptr) {
1398 // Set the IMPORTED flag, to help prevent overwriting
1399 // the techfile with a truncated version of it, unless
1400 // the filename of the techfile has been changed, in
1401 // which case the technology should be considered to
1402 // stand on its own, and is not considered a partially
1403 // complete imported version of the original techfile.
1404
1405 if (!strcmp(inname, nsptr->filename))
1406 nsptr->flags |= TECH_IMPORTED;
1407 }
1408 }
1409 }
1410 else if (!strncmp(tptr, "Depend", 6)) {
1411 dependencies = TRUE;
1412 tptr += 7;
1413 sscanf(tptr, "%s", keyword);
1414 if (!strcmp(keyword, objname)) {
1415 /* Load dependencies */
1416 while (1) {
1417 tptr += strlen(keyword) + 1;
1418 if (sscanf(tptr, "%s", keyword) != 1) break;
1419 if (keyword[0] == '\n' || keyword[0] == '\0') break;
1420 /* Recursive import */
1421 saveversion = version;
1422 importfromlibrary(mode, libname, keyword);
1423 version = saveversion;
1424 }
1425 }
1426 }
1427 }
1428 }
1429
1430 if ((version < 3.2) && (!dependencies)) {
1431 Fprintf(stderr, "Library does not have dependency list and cannot "
1432 "be trusted.\nLoad and rewrite library to update.\n");
1433 goto endload;
1434 }
1435
1436 newobject = new_library_object(mode, keyword, &redef, nsptr);
1437
1438 load_in_progress = True;
1439 if (objectread(ps, *newobject, 0, 0, mode, temp, DEFAULTCOLOR, nsptr) == False) {
1440
1441 if (library_object_unique(mode, *newobject, redef)) {
1442 add_object_to_library(mode, *newobject);
1443 cleanupaliases(mode);
1444
1445 /* pull in any instances of this object that */
1446 /* are defined in the library */
1447
1448 for(;;) {
1449 if (fgets(temp, 149, ps) == NULL) {
1450 Wprintf("Error in library.");
1451 goto endload;
1452 }
1453 else if (!strncmp(temp, "% EndLib", 8))
1454 break;
1455 else if (strstr(temp, "libinst") != NULL) {
1456 if ((tptr = strstr(temp, objname)) != NULL) {
1457 if (*(tptr - 1) == '/') {
1458 char *eptr = tptr;
1459 while (!isspace(*++eptr));
1460 *eptr = '\0';
1461 new_library_instance(mode - LIBRARY, tptr, temp, nsptr);
1462 }
1463 }
1464 }
1465 }
1466
1467 if (mode != FONTLIB) {
1468 composelib(mode);
1469 centerview(xobjs.libtop[mode]);
1470 }
1471 }
1472 }
1473
1474 endload:
1475 fclose(ps);
1476 version = PROG_VERSION;
1477 load_in_progress = False;
1478 }
1479
1480 /*------------------------------------------------------*/
1481 /* Copy all technologies' replace flags into temp flag. */
1482 /* Then clear the replace flags (replace none) */
1483 /*------------------------------------------------------*/
1484
1485 void TechReplaceSave()
1486 {
1487 TechPtr nsp;
1488
1489 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next)
1490 {
1491 if (nsp->flags & TECH_REPLACE)
1492 nsp->flags |= TECH_REPLACE_TEMP;
1493 else
1494 nsp->flags &= ~TECH_REPLACE_TEMP;
1495 nsp->flags &= ~TECH_REPLACE;
1496 }
1497 }
1498
1499 /*------------------------------------------------------*/
1500 /* Restore all technologies' replace flags */
1501 /*------------------------------------------------------*/
1502
1503 void TechReplaceRestore()
1504 {
1505 TechPtr nsp;
1506
1507 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next)
1508 {
1509 if (nsp->flags & TECH_REPLACE_TEMP)
1510 nsp->flags |= TECH_REPLACE;
1511 else
1512 nsp->flags &= ~TECH_REPLACE;
1513 }
1514 }
1515
1516 /*------------------------------------------------------*/
1517 /* Set all technologies' replace flags (replace all) */
1518 /*------------------------------------------------------*/
1519
1520 void TechReplaceAll()
1521 {
1522 TechPtr nsp;
1523
1524 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next)
1525 nsp->flags |= TECH_REPLACE;
1526 }
1527
1528 /*------------------------------------------------------*/
1529 /* Clear all technologies' replace flags (replace none) */
1530 /*------------------------------------------------------*/
1531
1532 void TechReplaceNone()
1533 {
1534 TechPtr nsp;
1535
1536 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next)
1537 nsp->flags &= ~TECH_REPLACE;
1538 }
1539
1540
1541 /*------------------------------------------------------*/
1542 /* Compare an object's name with a specific technology */
1543 /* */
1544 /* A missing "::" prefix separator or an empty prefix */
1545 /* both match a NULL technology or a technology name */
1546 /* that is an empty string (""). All of these */
1547 /* conditions indicate the default "user" technology. */
1548 /*------------------------------------------------------*/
1549
1550 Boolean CompareTechnology(objectptr cobj, char *technology)
1551 {
1552 char *cptr;
1553 Boolean result = FALSE;
1554
1555 if ((cptr = strstr(cobj->name, "::")) != NULL) {
1556 if (technology == NULL)
1557 result = (cobj->name == cptr) ? TRUE : FALSE;
1558 else {
1559 *cptr = '\0';
1560 if (!strcmp(cobj->name, technology)) result = TRUE;
1561 *cptr = ':';
1562 }
1563 }
1564 else if (technology == NULL)
1565 result = TRUE;
1566
1567 return result;
1568 }
1569
1570 /*------------------------------------------------------*/
1571 /* Find a technology record */
1572 /*------------------------------------------------------*/
1573
1574 TechPtr LookupTechnology(char *technology)
1575 {
1576 TechPtr nsp;
1577 Boolean usertech = FALSE;
1578
1579 // A NULL technology is allowed as equivalent to a
1580 // technology name of "" (null string)
1581
1582 if (technology == NULL)
1583 usertech = TRUE;
1584 else if (*technology == '\0')
1585 usertech = TRUE;
1586 else if (!strcmp(technology, "(user)"))
1587 usertech = TRUE;
1588
1589 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next) {
1590 if (usertech == TRUE) {
1591 if (*nsp->technology == '\0')
1592 return nsp;
1593 }
1594 if ((technology != NULL) && !strcmp(technology, nsp->technology))
1595 return nsp;
1596 }
1597 return NULL;
1598 }
1599
1600 /*------------------------------------------------------*/
1601 /* Find a technology according to the filename */
1602 /*------------------------------------------------------*/
1603
1604 TechPtr GetFilenameTechnology(char *filename)
1605 {
1606 TechPtr nsp;
1607
1608 if (filename == NULL) return NULL;
1609
1610 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next)
1611 if (!filecmp(filename, nsp->filename))
1612 return nsp;
1613
1614 return NULL;
1615 }
1616
1617 /*------------------------------------------------------*/
1618 /* Find a technology record corresponding to the */
1619 /* indicated object's technology. */
1620 /*------------------------------------------------------*/
1621
1622 TechPtr GetObjectTechnology(objectptr thisobj)
1623 {
1624 TechPtr nsp;
1625 char *cptr;
1626 /* int nlen; (jdk) */
1627
1628 cptr = strstr(thisobj->name, "::");
1629 if (cptr == NULL) return NULL;
1630 else *cptr = '\0';
1631
1632 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next)
1633 if (!strcmp(thisobj->name, nsp->technology))
1634 break;
1635
1636 *cptr = ':';
1637 return nsp;
1638 }
1639
1640 /*------------------------------------------------------*/
1641 /* Add a new technology name to the list */
1642 /*------------------------------------------------------*/
1643
1644 TechPtr AddNewTechnology(char *technology, char *filename)
1645 {
1646 TechPtr nsp;
1647 char usertech[] = "";
1648 char *localtech = technology;
1649
1650 // In the case where somebody has saved the contents of the user
1651 // technology to a file, create a technology->filename mapping
1652 // using a null string ("") for the technology name. If we are
1653 // only checking if a technology name exists (filename is NULL),
1654 // then ignore an reference to the user technology.
1655
1656 if (technology == NULL) {
1657 if (filename == NULL) return NULL;
1658 else localtech = usertech;
1659 }
1660
1661 for (nsp = xobjs.technologies; nsp != NULL; nsp = nsp->next) {
1662 if (!strcmp(localtech, nsp->technology)) {
1663
1664 /* A namespace may be created for an object that is a dependency */
1665 /* in a different technology. If so, it will have a NULL */
1666 /* filename, and the filename should be replaced if we ever load */
1667 /* the file that properly defines the technology. */
1668
1669 if ((nsp->filename == NULL) && (filename != NULL))
1670 nsp->filename = strdup(filename);
1671
1672 return nsp; /* Namespace already exists */
1673 }
1674 }
1675
1676 nsp = (TechPtr)malloc(sizeof(Technology));
1677 nsp->next = xobjs.technologies;
1678 if (filename == NULL)
1679 nsp->filename = NULL;
1680 else
1681 nsp->filename = strdup(filename);
1682 nsp->technology = strdup(localtech);
1683 nsp->flags = (u_char)0;
1684 xobjs.technologies = nsp;
1685
1686 return nsp;
1687 }
1688
1689 /*------------------------------------------------------*/
1690 /* Check an object's name for a technology, and add it */
1691 /* to the list of technologies if it has one. */
1692 /*------------------------------------------------------*/
1693
1694 void AddObjectTechnology(objectptr thisobj)
1695 {
1696 char *cptr;
1697
1698 cptr = strstr(thisobj->name, "::");
1699 if (cptr != NULL) {
1700 *cptr = '\0';
1701 AddNewTechnology(thisobj->name, NULL);
1702 *cptr = ':';
1703 }
1704 }
1705
1706 /*------------------------------------------------------*/
1707 /* Load a library page (given in parameter "mode") and */
1708 /* rename the library page to match the library name as */
1709 /* found in the file header. */
1710 /*------------------------------------------------------*/
1711
1712 Boolean loadlibrary(short mode)
1713 {
1714 FILE *ps;
1715 objinstptr saveinst;
1716 char temp[150], keyword[30], percentc, inname[150];
1717 TechPtr nsptr = NULL;
1718
1719 ps = libopen(_STR, mode, inname, 149);
1720
1721 if ((ps == NULL) && (mode == FONTLIB)) {
1722 /* We automatically try looking in all the usual places plus a */
1723 /* subdirectory named "fonts". */
1724
1725 sprintf(temp, "fonts/%s", _STR);
1726 ps = libopen(temp, mode, inname, 149);
1727 }
1728 if (ps == NULL) {
1729 Wprintf("Library not found.");
1730 return False;
1731 }
1732
1733 /* current version is PROG_VERSION; however, all libraries newer than */
1734 /* version 2.0 require "Version" in the header. So unnumbered */
1735 /* libraries may be assumed to be version 1.9 or earlier. */
1736
1737 version = 1.9;
1738 for(;;) {
1739 if (fgets(temp, 149, ps) == NULL) {
1740 Wprintf("Error in library.");
1741 fclose(ps);
1742 return False;
1743 }
1744 sscanf(temp, "%c %29s", &percentc, keyword);
1745
1746 /* Commands in header are PostScript comments (%) */
1747 if (percentc == '%') {
1748
1749 /* The library name in the header corresponds to the object */
1750 /* technology defined by the library. This no longer has */
1751 /* anything to do with the name of the library page where we */
1752 /* are loading this file. */
1753
1754 /* Save the technology, filename, and flags in the technology list. */
1755
1756 if ((mode != FONTLIB) && !strcmp(keyword, "Library")) {
1757 char *cptr, *nptr;
1758 cptr = strchr(temp, ':');
1759 if (cptr != NULL) {
1760 cptr += 2;
1761
1762 /* Don't write terminating newline to the object's name string */
1763 ridnewline(cptr);
1764
1765 /* The default user technology is written to the output */
1766 /* as "(user)". If this is found, replace it with a */
1767 /* null string. */
1768 if (!strcmp(cptr, "(user)")) cptr += 6;
1769
1770 /* Removing any leading pathname from the library name */
1771 if ((nptr = strrchr(cptr, '/')) != NULL) cptr = nptr + 1;
1772
1773 /* Remove any ".lps" extension from the library name */
1774
1775 nptr = strrchr(cptr, '.');
1776 if ((nptr != NULL) && !strcmp(nptr, ".lps")) *nptr = '\0';
1777
1778 nsptr = AddNewTechnology(cptr, inname);
1779
1780 if (nsptr) {
1781 // If anything was previously imported from this file
1782 // using importfromlibrary(), then the IMPORTED flag
1783 // will be set and needs to be cleared.
1784 nsptr->flags &= ~TECH_IMPORTED;
1785 }
1786 }
1787 }
1788
1789 /* This comment gives the Xcircuit version number */
1790 else if (!strcmp(keyword, "Version:")) {
1791 float tmpv;
1792 if (sscanf(temp, "%*c %*s %f", &tmpv) > 0) version = tmpv;
1793 }
1794
1795 /* This PostScript comment marks the end of the file header */
1796 else if (!strcmp(keyword, "XCircuitLib")) break;
1797 }
1798 }
1799
1800 /* Set the current top object to the library page so that any */
1801 /* expression parameters are computed with respect to the library, */
1802 /* not a page. Revert back to the page after loading the library. */
1803
1804 saveinst = areawin->topinstance;
1805 areawin->topinstance = xobjs.libtop[mode];
1806
1807 load_in_progress = True;
1808 objectread(ps, topobject, 0, 0, mode, temp, DEFAULTCOLOR, nsptr);
1809 load_in_progress = False;
1810 cleanupaliases(mode);
1811
1812 areawin->topinstance = saveinst;
1813
1814 if (mode != FONTLIB) {
1815 composelib(mode);
1816 centerview(xobjs.libtop[mode]);
1817 if (nsptr == NULL) nsptr = GetFilenameTechnology(inname);
1818 if (nsptr != NULL)
1819 Wprintf("Loaded library file %s", inname);
1820 else
1821 Wprintf("Loaded library file %s (technology %s)", inname,
1822 nsptr->technology);
1823 }
1824 else
1825 Wprintf("Loaded font file %s", inname);
1826
1827 version = PROG_VERSION;
1828 fclose(ps);
1829
1830 /* Check if the library is read-only by opening for append */
1831
1832 if ((mode != FONTLIB) && (nsptr != NULL)) {
1833 ps = fopen(inname, "a");
1834 if (ps == NULL)
1835 nsptr->flags |= TECH_READONLY;
1836 else
1837 fclose(ps);
1838 }
1839
1840 return True;
1841 }
1842
1843 /*---------------------------------------------------------*/
1844
1845 void startloadfile(int libnum)
1846 {
1847 int savemode;
1848 short firstpage = areawin->page;
1849
1850 while (nextfilename()) {
1851 loadfile(0, libnum);
1852
1853 /* find next undefined page */
1854
1855 while(areawin->page < xobjs.pages &&
1856 xobjs.pagelist[areawin->page]->pageinst != NULL) areawin->page++;
1857 changepage(areawin->page);
1858 }
1859 loadfile(0, libnum);
1860
1861
1862 /* Prevent page change from being registered as an undoable action */
1863 savemode = eventmode;
1864 eventmode = UNDO_MODE;
1865
1866 /* Display the first page loaded */
1867 newpage(firstpage);
1868 eventmode = savemode;
1869
1870 setsymschem();
1871 }
1872
1873 /*------------------------------------------------------*/
1874 /* normalloadfile() is a call to startloadfile(-1) */
1875 /* meaning load symbols to the User Library */
1876 /*------------------------------------------------------*/
1877
1878 void normalloadfile()
1879 {
1880 startloadfile(-1);
1881 }
1882
1883 /*------------------------------------------------------*/
1884 /* Import an xcircuit file onto the current page */
1885 /*------------------------------------------------------*/
1886
1887 void importfile()
1888 {
1889 while (nextfilename()) loadfile(1, -1);
1890 loadfile(1, -1);
1891 }
1892
1893 /*------------------------------------------------------*/
1894 /* Import an PPM graphic file onto the current page */
1895 /*------------------------------------------------------*/
1896
1897 #ifdef HAVE_CAIRO
1898 void importgraphic(void)
1899 {
1900 char inname[250];
1901 FILE *spcfile;
1902
1903 if (eventmode == CATALOG_MODE) {
1904 Wprintf("Cannot import a graphic while in the library window.");
1905 return;
1906 }
1907
1908 if (!nextfilename()) {
1909 xc_tilde_expand(_STR, 149);
1910 sscanf(_STR, "%149s", inname);
1911 if (!new_graphic(NULL, inname, 0, 0)) {
1912 Wprintf("Error: Graphic file not found.");
1913 return;
1914 }
1915 }
1916 else {
1917 Wprintf("Error: No graphic file to read.");
1918 return;
1919 }
1920 }
1921 #endif /* HAVE_CAIRO */
1922
1923 /*--------------------------------------------------------------*/
1924 /* Skip forward in the input file to the next comment line */
1925 /*--------------------------------------------------------------*/
1926
1927 void skiptocomment(char *temp, int length, FILE *ps)
1928 {
1929 int pch;
1930
1931 do {
1932 pch = getc(ps);
1933 } while (pch == '\n');
1934
1935 ungetc(pch, ps);
1936 if (pch == '%') fgets(temp, length, ps);
1937 }
1938
1939 /*--------------------------------------------------------------*/
1940 /* ASG file import functions: */
1941 /* This function loads a SPICE deck (hspice format) */
1942 /*--------------------------------------------------------------*/
1943
1944 #ifdef ASG
1945
1946 void importspice()
1947 {
1948 char inname[250];
1949 FILE *spcfile;
1950
1951 if (eventmode == CATALOG_MODE) {
1952 Wprintf("Cannot import a netlist while in the library window.");
1953 return;
1954 }
1955
1956 if (!nextfilename()) {
1957 xc_tilde_expand(_STR, 149);
1958 sscanf(_STR, "%149s", inname);
1959 spcfile = fopen(inname, "r");
1960 if (spcfile != NULL) {
1961 ReadSpice(spcfile);
1962 Route(areawin, False);
1963 fclose(spcfile);
1964 }
1965 else {
1966 Wprintf("Error: Spice file not found.");
1967 return;
1968 }
1969 }
1970 else {
1971 Wprintf("Error: No spice file to read.");
1972 return;
1973 }
1974 }
1975
1976 #endif
1977
1978 /*--------------------------------------------------------------*/
1979 /* Load an xcircuit file into xcircuit */
1980 /* */
1981 /* mode = 0 is a "load" function. Behavior: load on */
1982 /* current page if empty. Otherwise, load on first empty */
1983 /* page found. If no empty pages exist, create a new page */
1984 /* and load there. */
1985 /* mode = 1 is an "import" function. Behavior: add */
1986 /* contents of file to the current page. */
1987 /* mode = 2 is a "library load" function. Behavior: add */
1988 /* objects in file to the user library but ignore the */
1989 /* page contents. */
1990 /* */
1991 /* Return value: True if file was successfully loaded, False */
1992 /* if not. */
1993 /*--------------------------------------------------------------*/
1994
1995 typedef struct _connects *connectptr;
1996
1997 typedef struct _connects {
1998 short page;
1999 char *master;
2000 connectptr next;
2001 } connects;
2002
2003 Boolean loadfile(short mode, int libnum)
2004 {
2005 FILE *ps;
2006 char inname[150], temp[150], keyword[30], percentc, *pdchar;
2007 char teststr[50], teststr2[20], pagestr[100];
2008 short offx, offy, multipage, page, temppmode = 0;
2009 float tmpfl;
2010 XPoint pagesize;
2011 connects *connlist = NULL;
2012 struct stat statbuf;
2013 int loclibnum = (libnum == -1) ? USERLIB : libnum;
2014
2015 /* First, if we're in catalog mode, return with error */
2016
2017 if (eventmode == CATALOG_MODE) {
2018 Wprintf("Cannot load file from library window");
2019 return False;
2020 }
2021
2022 /* Do tilde/variable expansions on filename and open */
2023 ps = fileopen(_STR, "ps", inname, 149);
2024
2025 /* Could possibly be a library file? */
2026 /* (Note---loadfile() has no problems loading libraries */
2027 /* except for setting technology names and setting the */
2028 /* library page view at the end. The loadlibrary() routine */
2029 /* should probably be merged into this one.) */
2030
2031 if (ps == NULL) {
2032 ps = fileopen(_STR, "lps", NULL, 0);
2033 if (ps != NULL) {
2034 fclose(ps);
2035 loadlibrary(loclibnum);
2036 return True;
2037 }
2038 }
2039 else if (!strcmp(inname + strlen(inname) - 4, ".lps")) {
2040 fclose(ps);
2041 loadlibrary(loclibnum);
2042 return True;
2043 }
2044
2045
2046 #ifdef LGF
2047 /* Could possibly be an LGF file? */
2048 if (ps == NULL) {
2049 ps = fileopen(_STR, "lgf", NULL, 0);
2050 if (ps != NULL) {
2051 fclose(ps);
2052 loadlgf(mode);
2053 return True;
2054 }
2055 }
2056
2057 /* Could possibly be an LGF backup (.lfo) file? */
2058 if (ps == NULL) {
2059 ps = fileopen(_STR, "lfo", NULL, 0);
2060 if (ps != NULL) {
2061 fclose(ps);
2062 loadlgf(mode);
2063 return True;
2064 }
2065 }
2066 #endif /* LGF */
2067
2068 /* Check for empty file---don't attempt to read empty files */
2069 if (ps != NULL) {
2070 if (fstat(fileno(ps), &statbuf) == 0 && (statbuf.st_size == (off_t)0)) {
2071 fclose(ps);
2072 ps = NULL;
2073 }
2074 }
2075
2076 /* What to do if no file was found. . . */
2077
2078 if (ps == NULL) {
2079 if (topobject->parts == 0 && (mode == 0)) {
2080
2081 /* Check for file extension, and remove if "ps". */
2082
2083 if ((pdchar = strchr(_STR, '.')) != NULL)
2084 if (!strcmp(pdchar + 1, "ps")) *pdchar = '\0';
2085
2086 free(xobjs.pagelist[areawin->page]->filename);
2087 xobjs.pagelist[areawin->page]->filename = strdup(_STR);
2088
2089 /* If the name has a path component, use only the root */
2090 /* for the object name, but the full path for the filename. */
2091
2092 if ((pdchar = strrchr(_STR, '/')) != NULL)
2093 sprintf(topobject->name, "%s", pdchar + 1);
2094 else
2095 sprintf(topobject->name, "%s", _STR);
2096
2097 renamepage(areawin->page);
2098 printname(topobject);
2099 Wprintf("Starting new drawing");
2100 }
2101 else {
2102 Wprintf("Can't find file %s, won't overwrite current page", _STR);
2103 }
2104 return False;
2105 }
2106
2107 version = 1.0;
2108 multipage = 1;
2109 pagesize.x = 612;
2110 pagesize.y = 792;
2111
2112 for(;;) {
2113 if (fgets(temp, 149, ps) == NULL) {
2114 Wprintf("Error: EOF in or before prolog.");
2115 return False;
2116 }
2117 sscanf(temp, "%c%29s", &percentc, keyword);
2118 for (pdchar = keyword; isspace(*pdchar); pdchar++);
2119 if (percentc == '%') {
2120 if (!strcmp(pdchar, "XCircuit")) break;
2121 if (!strcmp(pdchar, "XCircuitLib")) {
2122 /* version control in libraries is post version 1.9 */
2123 if (version == 1.0) version = 1.9;
2124 break;
2125 }
2126 if (!strcmp(pdchar, "%Page:")) break;
2127 if (strstr(pdchar, "PS-Adobe") != NULL)
2128 temppmode = (strstr(temp, "EPSF") != NULL) ? 0 : 1;
2129 else if (!strcmp(pdchar, "Version:"))
2130 sscanf(temp, "%*c%*s %f", &version);
2131 else if (!strcmp(pdchar, "%Pages:")) {
2132 pdchar = advancetoken(temp);
2133 multipage = atoi(pdchar);
2134 }
2135 /* Crash files get renamed back to their original filename */
2136 else if (!strcmp(pdchar, "%Title:")) {
2137 if (xobjs.tempfile != NULL)
2138 if (!strcmp(inname, xobjs.tempfile))
2139 sscanf(temp, "%*c%*s %s", inname);
2140 }
2141 else if ((temppmode == 1) && !strcmp(pdchar, "%BoundingBox:")) {
2142 short botx, boty;
2143 sscanf(temp, "%*s %hd %hd %hd %hd", &botx, &boty,
2144 &(pagesize.x), &(pagesize.y));
2145 pagesize.x += botx;
2146 pagesize.y += boty;
2147 }
2148
2149 }
2150 #ifdef LGF
2151 else if (percentc == '-' && !strcmp(keyword, "5")) {
2152 fclose(ps);
2153 loadlgf(mode);
2154 return True;
2155 }
2156 #endif
2157 }
2158
2159 /* Look for old-style files (no %%Page; maximum one page in file) */
2160
2161 if (!strcmp(pdchar, "XCircuit"))
2162 skiptocomment(temp, 149, ps);
2163
2164 for (page = 0; page < multipage; page++) {
2165 sprintf(pagestr, "%d", page + 1);
2166
2167 /* read out-of-page library definitions */
2168
2169 if (strstr(temp, "%%Page:") == NULL && strstr(temp, "offsets") == NULL) {
2170 load_in_progress = True;
2171 objectread(ps, topobject, 0, 0, loclibnum, temp, DEFAULTCOLOR, NULL);
2172 load_in_progress = False;
2173 }
2174
2175 if (strstr(temp, "%%Page:") != NULL) {
2176 sscanf(temp + 8, "%99s", pagestr);
2177
2178 /* Read the next line so any keywords in the Page name don't */
2179 /* confuse the parser. */
2180 if (fgets(temp, 149, ps) == NULL) {
2181 Wprintf("Error: bad page header.");
2182 return False;
2183 }
2184
2185 /* Library load mode: Ignore all pages, just load objects */
2186 if (mode == 2) {
2187 while (strstr(temp, "showpage") == NULL) {
2188 if (fgets(temp, 149, ps) == NULL) {
2189 Wprintf("Error: bad page definition.");
2190 return False;
2191 }
2192 }
2193 skiptocomment(temp, 149, ps);
2194 continue;
2195 }
2196 }
2197
2198 /* go to new page if necessary */
2199
2200 if (page > 0) {
2201
2202 /* find next undefined page */
2203
2204 while(areawin->page < xobjs.pages &&
2205 xobjs.pagelist[areawin->page]->pageinst != NULL) areawin->page++;
2206 changepage(areawin->page);
2207 }
2208
2209 /* If this file was a library file then there is no page to load */
2210
2211 if (strstr(temp, "EndLib") != NULL) {
2212 composelib(loclibnum);
2213 centerview(xobjs.libtop[mode]);
2214 Wprintf("Loaded library.");
2215 return True;
2216 }
2217
2218 /* good so far; let's clear out the old data structure */
2219
2220 if (mode == 0) {
2221 reset(topobject, NORMAL);
2222 pagereset(areawin->page);
2223 xobjs.pagelist[areawin->page]->pmode = temppmode;
2224 if (temppmode == 1) {
2225 xobjs.pagelist[areawin->page]->pagesize.x = pagesize.x;
2226 xobjs.pagelist[areawin->page]->pagesize.y = pagesize.y;
2227 }
2228 }
2229 else {
2230 invalidate_netlist(topobject);
2231 /* ensure that the netlist for topobject is destroyed */
2232 freenetlist(topobject);
2233 }
2234
2235 /* clear the undo record */
2236 flush_undo_stack();
2237
2238 /* read to the "scale" line, picking up inch/cm type, drawing */
2239 /* scale, and grid/snapspace along the way */
2240
2241 offx = offy = 0;
2242 for(;;) {
2243 if (strstr(temp, "offsets") != NULL) {
2244 /* Prior to version 3.1.28 only. . . */
2245 sscanf(temp, "%c %hd %hd %*s", &percentc, &offx, &offy);
2246 if(percentc != '%') {
2247 Wprintf("Something wrong in offsets line.");
2248 offx = offy = 0;
2249 }
2250 }
2251
2252 if ((temppmode == 1) && strstr(temp, "%%PageBoundingBox:") != NULL) {
2253 /* Recast the individual page size if specified per page */
2254 sscanf(temp, "%*s %*d %*d %hd %hd",
2255 &xobjs.pagelist[areawin->page]->pagesize.x,
2256 &xobjs.pagelist[areawin->page]->pagesize.y);
2257 }
2258 else if (strstr(temp, "drawingscale") != NULL)
2259 sscanf(temp, "%*c %hd:%hd %*s",
2260 &xobjs.pagelist[areawin->page]->drawingscale.x,
2261 &xobjs.pagelist[areawin->page]->drawingscale.y);
2262
2263 else if (strstr(temp, "hidden") != NULL)
2264 topobject->hidden = True;
2265
2266 else if (strstr(temp, "is_symbol") != NULL) {
2267 sscanf(temp, "%*c %49s", teststr);
2268 checkschem(topobject, teststr);
2269 }
2270 else if (strstr(temp, "is_primary") != NULL) {
2271 /* objectptr master; (jdk) */
2272 connects *newconn;
2273
2274 /* Save information about master schematic and link at end of load */
2275 sscanf(temp, "%*c %49s", teststr);
2276 newconn = (connects *)malloc(sizeof(connects));
2277 newconn->next = connlist;
2278 connlist = newconn;
2279 newconn->page = areawin->page;
2280 newconn->master = strdup(teststr);
2281 }
2282
2283 else if (strstr(temp, "gridspace"))
2284 sscanf(temp, "%*c %f %f %*s", &xobjs.pagelist[areawin->page]->gridspace,
2285 &xobjs.pagelist[areawin->page]->snapspace);
2286 else if (strstr(temp, "scale") != NULL || strstr(temp, "rotate") != NULL) {
2287 /* rotation (landscape mode) is optional; parse accordingly */
2288
2289 sscanf(temp, "%f %49s", &tmpfl, teststr);
2290 if (strstr(teststr, "scale") != NULL) {
2291 #ifndef TCL_WRAPPER
2292 setgridtype(teststr);
2293 #else
2294 if (strstr(teststr, "inch"))
2295 Tcl_Eval(xcinterp, "xcircuit::coordstyle inches");
2296 else
2297 Tcl_Eval(xcinterp, "xcircuit::coordstyle centimeters");
2298 #endif
2299 xobjs.pagelist[areawin->page]->outscale = tmpfl;
2300 }
2301 else if (!strcmp(teststr, "rotate")) {
2302 xobjs.pagelist[areawin->page]->orient = (short)tmpfl;
2303 fgets(temp, 149, ps);
2304 sscanf(temp, "%f %19s", &tmpfl, teststr2);
2305 if (strstr(teststr2, "scale") != NULL) {
2306 #ifndef TCL_WRAPPER
2307 setgridtype(teststr2);
2308 #else
2309 if (strstr(teststr2, "inch"))
2310 Tcl_Eval(xcinterp, "xcircuit::coordstyle inches");
2311 else
2312 Tcl_Eval(xcinterp, "xcircuit::coordstyle centimeters");
2313 #endif
2314 xobjs.pagelist[areawin->page]->outscale = tmpfl;
2315 }
2316 else {
2317 sscanf(temp, "%*f %*f %19s", teststr2);
2318 if (!strcmp(teststr2, "scale"))
2319 xobjs.pagelist[areawin->page]->outscale = tmpfl /
2320 getpsscale(1.0, areawin->page);
2321 else {
2322 Wprintf("Error in scale/rotate constructs.");
2323 return False;
2324 }
2325 }
2326 }
2327 else { /* old style scale? */
2328 sscanf(temp, "%*f %*s %19s", teststr2);
2329 if ((teststr2 != NULL) && (!strcmp(teststr2, "scale")))
2330 xobjs.pagelist[areawin->page]->outscale = tmpfl /
2331 getpsscale(1.0, areawin->page);
2332 else {
2333 Wprintf("Error in scale/rotate constructs.");
2334 return False;
2335 }
2336 }
2337 }
2338 else if (strstr(temp, "setlinewidth") != NULL) {
2339 sscanf(temp, "%f %*s", &xobjs.pagelist[areawin->page]->wirewidth);
2340 xobjs.pagelist[areawin->page]->wirewidth /= 1.3;
2341 break;
2342 }
2343 else if (strstr(temp, "insertion") != NULL) {
2344 /* read in an included background image */
2345 readbackground(ps);
2346 }
2347 else if (strstr(temp, "<<") != NULL) {
2348 char *buffer = temp, *endptr;
2349 /* Make sure we have the whole dictionary before calling */
2350 while (strstr(buffer, ">>") == NULL) {
2351 if (buffer == temp) {
2352 buffer = (char *)malloc(strlen(buffer) + 150);
2353 strcpy(buffer, temp);
2354 }
2355 else
2356 buffer = (char *)realloc(buffer, strlen(buffer) + 150);
2357 endptr = ridnewline(buffer);
2358 *endptr++ = ' ';
2359 fgets(endptr, 149, ps);
2360 }
2361 /* read top-level parameter dictionary */
2362 readparams(NULL, NULL, topobject, buffer);
2363 if (buffer != temp) free(buffer);
2364 }
2365
2366 if (fgets(temp, 149, ps) == NULL) {
2367 Wprintf("Error: Problems encountered in page header.");
2368 return False;
2369 }
2370 }
2371
2372 load_in_progress = True;
2373 objectread(ps, topobject, offx, offy, LIBRARY, temp, DEFAULTCOLOR, NULL);
2374 load_in_progress = False;
2375
2376 /* skip to next page boundary or file trailer */
2377
2378 if (strstr(temp, "showpage") != NULL && multipage != 1) {
2379 char *fstop;
2380
2381 skiptocomment(temp, 149, ps);
2382
2383 /* check for new filename if this is a crash recovery file */
2384 if ((fstop = strstr(temp, "is_filename")) != NULL) {
2385 strncpy(inname, temp + 2, (int)(fstop - temp - 3));
2386 *(inname + (int)(fstop - temp) - 3) = '\0';
2387 fgets(temp, 149, ps);
2388 skiptocomment(temp, 149, ps);
2389 }
2390 }
2391
2392 /* Finally: set the filename and pagename for this page */
2393
2394 if (mode == 0) {
2395 char tpstr[6], *rootptr;
2396
2397 /* Set filename and page title. */
2398
2399 if (xobjs.pagelist[areawin->page]->filename != NULL)
2400 free(xobjs.pagelist[areawin->page]->filename);
2401 xobjs.pagelist[areawin->page]->filename = strdup(inname);
2402
2403 /* Get the root name (after all path components) */
2404
2405 rootptr = strrchr(xobjs.pagelist[areawin->page]->filename, '/');
2406 if (rootptr == NULL) rootptr = xobjs.pagelist[areawin->page]->filename;
2407 else rootptr++;
2408
2409 /* If we didn't read in a page name from the %%Page: header line, then */
2410 /* set the page name to the root name of the file. */
2411
2412 sprintf(tpstr, "%d", page + 1);
2413 if (!strcmp(pagestr, tpstr)) {
2414 if (rootptr == NULL)
2415 sprintf(topobject->name, "Page %d", page + 1);
2416 else
2417 sprintf(topobject->name, "%.79s", rootptr);
2418
2419 /* Delete filename extensions ".ps" or ".eps" from the page name */
2420 if ((pdchar = strrchr(topobject->name, '.')) != NULL) {
2421 if (!strcmp(pdchar + 1, "ps") || !strcmp(pdchar + 1, "eps"))
2422 *pdchar = '\0';
2423 }
2424 }
2425 else
2426 sprintf(topobject->name, "%.79s", pagestr);
2427
2428 renamepage(areawin->page);
2429 }
2430
2431 /* set object position to fit to window separately for each page */
2432 calcbbox(areawin->topinstance);
2433 centerview(areawin->topinstance);
2434 }
2435
2436 /* Crash file recovery: read any out-of-page library definitions tacked */
2437 /* onto the end of the file into the user library. */
2438 if (strncmp(temp, "%%Trailer", 9)) {
2439 load_in_progress = True;
2440 objectread(ps, topobject, 0, 0, USERLIB, temp, DEFAULTCOLOR, NULL);
2441 load_in_progress = False;
2442 }
2443
2444 cleanupaliases(USERLIB);
2445
2446 /* Connect master->slave schematics */
2447 while (connlist != NULL) {
2448 connects *thisconn = connlist;
2449 objectptr master = NameToPageObject(thisconn->master, NULL, NULL);
2450 if (master) {
2451 xobjs.pagelist[thisconn->page]->pageinst->thisobject->symschem = master;
2452 xobjs.pagelist[thisconn->page]->pageinst->thisobject->schemtype = SECONDARY;
2453 }
2454 else {
2455 Fprintf(stderr, "Error: Cannot find primary schematic for %s\n",
2456 xobjs.pagelist[thisconn->page]->pageinst->thisobject->name);
2457 }
2458 connlist = thisconn->next;
2459 free(thisconn->master);
2460 free(thisconn);
2461 }
2462
2463 Wprintf("Loaded file: %s (%d page%s)", inname, multipage,
2464 (multipage > 1 ? "s" : ""));
2465
2466 composelib(loclibnum);
2467 centerview(xobjs.libtop[loclibnum]);
2468 composelib(PAGELIB);
2469
2470 if (version > PROG_VERSION + VEPS) {
2471 Wprintf("WARNING: file %s is version %2.1f vs. executable version %2.1f",
2472 inname, version, PROG_VERSION);
2473 }
2474
2475 version = PROG_VERSION;
2476 fclose(ps);
2477 return True;
2478 }
2479
2480 /*------------------------------------------------------*/
2481 /* Object name comparison: True if names are equal, */
2482 /* not counting leading underscores. */
2483 /*------------------------------------------------------*/
2484
2485 int objnamecmp(char *name1, char *name2)
2486 {
2487 char *n1ptr = name1;
2488 char *n2ptr = name2;
2489
2490 while (*n1ptr == '_') n1ptr++;
2491 while (*n2ptr == '_') n2ptr++;
2492
2493 return (strcmp(n1ptr, n2ptr));
2494 }
2495
2496 /*------------------------------------------------------*/
2497 /* Standard delimiter matching character. */
2498 /*------------------------------------------------------*/
2499
2500 char standard_delimiter_end(char source)
2501 {
2502 char target;
2503 switch(source) {
2504 case '(': target = ')'; break;
2505 case '[': target = ']'; break;
2506 case '{': target = '}'; break;
2507 case '<': target = '>'; break;
2508 default: target = source;
2509 }
2510 return target;
2511 }
2512
2513 /*------------------------------------------------------*/
2514 /* Find matching parenthesis, bracket, brace, or tag */
2515 /* Don't count when backslash character '\' is in front */
2516 /*------------------------------------------------------*/
2517
2518 u_char *find_delimiter(u_char *fstring)
2519 {
2520 int count = 1;
2521
2522 u_char *search = fstring;
2523 u_char source = *fstring;
2524 u_char target;
2525
2526 target = (u_char)standard_delimiter_end((char)source);
2527 while (*++search != '\0') {
2528 if (*search == source && *(search - 1) != '\\') count++;
2529 else if (*search == target && *(search - 1) != '\\') count--;
2530 if (count == 0) break;
2531 }
2532 return search;
2533 }
2534
2535 /*----------------------------------------------------------------------*/
2536 /* Remove unnecessary font change information from a label */
2537 /*----------------------------------------------------------------------*/
2538
2539 void cleanuplabel(stringpart **strhead)
2540 {
2541 stringpart *curpart = *strhead;
2542 int oldfont, curfont;
2543 Boolean fline = False;
2544
2545 oldfont = curfont = -1;
2546
2547 while (curpart != NULL) {
2548 switch (curpart->type) {
2549 case FONT_NAME:
2550 if (curfont == curpart->data.font) {
2551 /* Font change is redundant: remove it */
2552 /* Careful! font changes remove overline/underline; if */
2553 /* either one is in effect, replace it with "noline" */
2554 if (fline)
2555 curpart->type = NOLINE;
2556 else
2557 curpart = deletestring(curpart, strhead, NULL);
2558 }
2559 else {
2560 curfont = curpart->data.font;
2561 }
2562 break;
2563
2564 case FONT_SCALE:
2565 /* Old style font scale is always written absolute, not relative. */
2566 /* Changes in scale were not allowed, so just get rid of them. */
2567 if (version < 2.25)
2568 curpart = deletestring(curpart, strhead, areawin->topinstance);
2569 break;
2570
2571 /* A font change may occur inside a parameter, so any font */
2572 /* declaration after a parameter must be considered to be */
2573 /* intentional. */
2574
2575 case PARAM_END:
2576 curfont = oldfont = -1;
2577 break;
2578
2579 case OVERLINE: case UNDERLINE:
2580 fline = True;
2581 break;
2582
2583 case NOLINE:
2584 fline = False;
2585 break;
2586
2587 case NORMALSCRIPT: case RETURN:
2588 if (oldfont != -1) {
2589 curfont = oldfont;
2590 oldfont = -1;
2591 }
2592 break;
2593
2594 case SUBSCRIPT: case SUPERSCRIPT:
2595 if (oldfont == -1)
2596 oldfont = curfont;
2597 break;
2598 }
2599 if (curpart != NULL)
2600 curpart = curpart->nextpart;
2601 }
2602 }
2603
2604 /*----------------------------------------------------------------------*/
2605 /* Read label segments */
2606 /*----------------------------------------------------------------------*/
2607
2608 void readlabel(objectptr localdata, char *lineptr, stringpart **strhead)
2609 {
2610 Boolean fline = False;
2611 /* char *sptr; (jdk) */
2612 short j;
2613 char *endptr, *segptr = lineptr;
2614 char key[100];
2615 stringpart *newpart;
2616 oparamptr ops;
2617
2618 while (*segptr != '\0') { /* Look through all segments */
2619
2620 while (isspace(*segptr) && (*segptr != '\0')) segptr++;
2621
2622 if (*segptr == '(' || *segptr == '{') {
2623 endptr = find_delimiter(segptr);
2624 *endptr++ = '\0';
2625 /* null string (e.g., null parameter substitution) */
2626 if ((*segptr == '(') && (*(segptr + 1) == '\0')) {
2627 segptr = endptr;
2628 continue;
2629 }
2630 }
2631 else if (*segptr == '\0' || *segptr == '}') break;
2632
2633 makesegment(strhead, *strhead);
2634 newpart = *strhead;
2635
2636 /* Embedded command is in braces: {} */
2637
2638 if (*segptr == '{') {
2639
2640 /* Find the command for this PostScript procedure */
2641 char *cmdptr = endptr - 2;
2642 while (isspace(*cmdptr)) cmdptr--;
2643 while (!isspace(*cmdptr) && (cmdptr > segptr)) cmdptr--;
2644 cmdptr++;
2645 segptr++;
2646
2647 if (!strncmp(cmdptr, "Ss", 2))
2648 newpart->type = SUPERSCRIPT;
2649 else if (!strncmp(cmdptr, "ss", 2))
2650 newpart->type = SUBSCRIPT;
2651 else if (!strncmp(cmdptr, "ns", 2))
2652 newpart->type = NORMALSCRIPT;
2653 else if (!strncmp(cmdptr, "hS", 2))
2654 newpart->type = HALFSPACE;
2655 else if (!strncmp(cmdptr, "qS", 2))
2656 newpart->type = QTRSPACE;
2657 else if (!strncmp(cmdptr, "CR", 2)) {
2658 newpart->type = RETURN;
2659 newpart->data.flags = 0;
2660 }
2661 else if (!strcmp(cmdptr, "Ts")) /* "Tab set" command */
2662 newpart->type = TABSTOP;
2663 else if (!strcmp(cmdptr, "Tf")) /* "Tab forward" command */
2664 newpart->type = TABFORWARD;
2665 else if (!strcmp(cmdptr, "Tb")) /* "Tab backward" command */
2666 newpart->type = TABBACKWARD;
2667 else if (!strncmp(cmdptr, "ol", 2)) {
2668 newpart->type = OVERLINE;
2669 fline = True;
2670 }
2671 else if (!strncmp(cmdptr, "ul", 2)) {
2672 newpart->type = UNDERLINE;
2673 fline = True;
2674 }
2675 else if (!strncmp(cmdptr, "sce", 3)) { /* revert to default color */
2676 newpart->type = FONT_COLOR;
2677 newpart->data.color = DEFAULTCOLOR;
2678 }
2679 else if (cmdptr == segptr) { /* cancel over- or underline */
2680 newpart->type = NOLINE;
2681 fline = False;
2682 }
2683 /* To-do: replace old-style backspace with tab stop */
2684 else if (!strcmp(cmdptr, "bs")) {
2685 Wprintf("Warning: Obsolete backspace command ommitted in text");
2686 }
2687 else if (!strcmp(cmdptr, "Kn")) { /* "Kern" command */
2688 int kx, ky;
2689 sscanf(segptr, "%d %d", &kx, &ky);
2690 newpart->type = KERN;
2691 newpart->data.kern[0] = kx;
2692 newpart->data.kern[1] = ky;
2693 }
2694 else if (!strcmp(cmdptr, "MR")) { /* "Margin stop" command */
2695 int width;
2696 sscanf(segptr, "%d", &width);
2697 newpart->type = MARGINSTOP;
2698 newpart->data.width = width;
2699 }
2700 else if (!strcmp(cmdptr, "scb")) { /* change color command */
2701 float cr, cg, cb;
2702 int cval, cindex;
2703 sscanf(segptr, "%f %f %f", &cr, &cg, &cb);
2704 newpart->type = FONT_COLOR;
2705 cindex = rgb_alloccolor((int)(cr * 65535), (int)(cg * 65535),
2706 (int)(cb * 65535));
2707 newpart->data.color = cindex;
2708 }
2709 else if (!strcmp(cmdptr, "cf")) { /* change font or scale command */
2710 char *nextptr, *newptr = segptr;
2711
2712 /* Set newptr to the fontname and nextptr to the next token. */
2713 while (*newptr != '/' && *newptr != '\0') newptr++;
2714 if (*newptr++ == '\0') {
2715 Wprintf("Error: Bad change-font command");
2716 newpart->type = NOLINE; /* placeholder */
2717 }
2718 for (nextptr = newptr; !isspace(*nextptr); nextptr++);
2719 *(nextptr++) = '\0';
2720 while (isspace(*nextptr)) nextptr++;
2721
2722 for (j = 0; j < fontcount; j++)
2723 if (!strcmp(newptr, fonts[j].psname))
2724 break;
2725
2726 if (j == fontcount) /* this is a non-loaded font */
2727 if (loadfontfile(newptr) < 0) {
2728 if (fontcount > 0) {
2729 Wprintf("Error: Font \"%s\" not found---using default.", newptr);
2730 j = 0;
2731 }
2732 else {
2733 Wprintf("Error: No fonts!");
2734 newpart->type = NOLINE; /* placeholder */
2735 }
2736 }
2737
2738 if (isdigit(*nextptr)) { /* second form of "cf" command---includes scale */
2739 float locscale;
2740 sscanf(nextptr, "%f", &locscale);
2741 newpart->type = FONT_SCALE;
2742 newpart->data.scale = locscale;
2743 makesegment(strhead, *strhead);
2744 newpart = *strhead;
2745 }
2746 newpart->type = FONT_NAME;
2747 newpart->data.font = j;
2748 }
2749 else { /* This exec isn't a known label function */
2750 Wprintf("Error: unknown substring function");
2751 newpart->type = NOLINE; /* placeholder */
2752 }
2753 }
2754
2755 /* Text substring is in parentheses: () */
2756
2757 else if (*segptr == '(') {
2758 if (fline == True) {
2759 newpart->type = NOLINE;
2760 makesegment(strhead, *strhead);
2761 newpart = *strhead;
2762 fline = False;
2763 }
2764 newpart->type = TEXT_STRING;
2765 newpart->data.string = (u_char *)malloc(1 + strlen(++segptr));
2766
2767 /* Copy string, translating octal codes into 8-bit characters */
2768 parse_ps_string(segptr, newpart->data.string, strlen(segptr), TRUE, TRUE);
2769 }
2770
2771 /* Parameterized substrings are denoted by parameter key. */
2772 /* The parameter (default and/or substitution value) is */
2773 /* assumed to exist. */
2774
2775 else {
2776
2777 parse_ps_string(segptr, key, 99, FALSE, TRUE);
2778 if (strlen(key) > 0) {
2779 newpart->type = PARAM_START;
2780 newpart->data.string = (char *)malloc(1 + strlen(key));
2781 strcpy(newpart->data.string, key);
2782
2783 /* check for compatibility between the parameter value and */
2784 /* the number of parameters and parameter type. */
2785
2786 ops = match_param(localdata, key);
2787 if (ops == NULL) {
2788 Fprintf(stderr, "readlabel() error: No such parameter %s!\n", key);
2789 deletestring(newpart, strhead, areawin->topinstance);
2790 }
2791
2792 /* Fprintf(stdout, "Parameter %s called from object %s\n", */
2793 /* key, localdata->name); */
2794 }
2795 endptr = segptr + 1;
2796 while (!isspace(*endptr) && (*endptr != '\0')) endptr++;
2797 }
2798 segptr = endptr;
2799 }
2800 }
2801
2802 /*--------------------------------------*/
2803 /* skip over whitespace in string input */
2804 /*--------------------------------------*/
2805
2806 char *skipwhitespace(char *lineptr)
2807 {
2808 char *locptr = lineptr;
2809
2810 while (isspace(*locptr) && (*locptr != '\n') && (*locptr != '\0')) locptr++;
2811 return locptr;
2812 }
2813
2814 /*-------------------------------------------*/
2815 /* advance to the next token in string input */
2816 /*-------------------------------------------*/
2817
2818 char *advancetoken(char *lineptr)
2819 {
2820 char *locptr = lineptr;
2821
2822 while (!isspace(*locptr) && (*locptr != '\n') && (*locptr != '\0')) locptr++;
2823 while (isspace(*locptr) && (*locptr != '\n') && (*locptr != '\0')) locptr++;
2824 return locptr;
2825 }
2826
2827 /*------------------------------------------------------*/
2828 /* Read a parameter list for an object instance call. */
2829 /* This uses the key-value dictionary method but also */
2830 /* allows the "old style" in which each parameter */
2831 /* was automatically assigned the key v1, v2, etc. */
2832 /*------------------------------------------------------*/
2833
2834 void readparams(objectptr localdata, objinstptr newinst, objectptr libobj,
2835 char *buffer)
2836 {
2837 oparamptr newops, objops, fops;
2838 char *arrayptr, *endptr, *arraynext;
2839 int paramno = 0;
2840 char paramkey[100];
2841
2842 if ((arrayptr = strstr(buffer, "<<")) == NULL)
2843 if ((arrayptr = strchr(buffer, '[')) == NULL)
2844 return;
2845
2846 endptr = find_delimiter(arrayptr);
2847 if (*arrayptr == '<') {
2848 arrayptr++; /* move to second '<' in "<<" */
2849 endptr--; /* back up to first '>' in ">>" */
2850 }
2851
2852 /* move to next non-space token after opening bracket */
2853 arrayptr++;
2854 while (isspace(*arrayptr) && *arrayptr != '\0') arrayptr++;
2855
2856 while ((*arrayptr != '\0') && (arrayptr < endptr)) {
2857
2858 newops = (oparamptr)malloc(sizeof(oparam));
2859
2860 /* Arrays contain values only. Dictionaries contain key:value pairs */
2861 if (*endptr == '>') { /* dictionary type */
2862 if (*arrayptr != '/') {
2863 Fprintf(stdout, "Error: Dictionary key is a literal, not a name\n");
2864 }
2865 else arrayptr++; /* Skip PostScript name delimiter */
2866 parse_ps_string(arrayptr, paramkey, 99, FALSE, TRUE);
2867 newops->key = (char *)malloc(1 + strlen(paramkey));
2868 strcpy(newops->key, paramkey);
2869 arrayptr = advancetoken(arrayptr);
2870 }
2871 else { /* array type; keys are "v1", "v2", etc. */
2872 paramno++;
2873 newops->key = (char *)malloc(6);
2874 sprintf(newops->key, "v%d", paramno);
2875 }
2876
2877 /* Find matching parameter in object definition */
2878 if (newinst) {
2879 objops = match_param(libobj, newops->key);
2880 if (objops == NULL) {
2881 Fprintf(stdout, "Error: parameter %s does not exist in object %s!\n",
2882 newops->key, libobj->name);
2883 free(newops->key);
2884 free(newops);
2885 return;
2886 }
2887 }
2888
2889 /* Add to instance's parameter list */
2890 /* If newinst is null, then the parameters are added to libobj */
2891 newops->next = NULL;
2892 if (newinst) {
2893
2894 /* Delete any parameters with duplicate names. This */
2895 /* This may indicate an expression parameter that was */
2896 /* precomputed while determining the bounding box. */
2897
2898 for (fops = newinst->params; fops != NULL; fops = fops->next)
2899 if (!strcmp(fops->key, newops->key))
2900 if ((fops = free_instance_param(newinst, fops)) == NULL)
2901 break;
2902
2903 if (newinst->params == NULL)
2904 newinst->params = newops;
2905 else {
2906 for (fops = newinst->params; fops->next != NULL; fops = fops->next);
2907 fops->next = newops;
2908 }
2909 }
2910 else {
2911 if (libobj->params == NULL)
2912 libobj->params = newops;
2913 else {
2914 for (fops = libobj->params; fops->next != NULL; fops = fops->next);
2915 fops->next = newops;
2916 }
2917 }
2918
2919 /* Fill in "which" entry from the object default */
2920 newops->which = (newinst) ? objops->which : 0;
2921
2922 /* Check next token. If not either end-of-dictionary or */
2923 /* the next parameter key, then value is an expression. */
2924 /* Expressions are written as two strings, the first the */
2925 /* result of evaluting the expression, and the second the */
2926 /* expression itself, followed by "pop" to prevent the */
2927 /* PostScript interpreter from trying to evaluate the */
2928 /* expression (which is not in PostScript). */
2929
2930 if (*arrayptr == '(' || *arrayptr == '{')
2931 arraynext = find_delimiter(arrayptr);
2932 else
2933 arraynext = arrayptr;
2934 arraynext = advancetoken(arraynext);
2935
2936 if ((*endptr == '>') && (arraynext < endptr) && (*arraynext != '/')) {
2937 char *substrend, *arraysave;
2938
2939 if (*arraynext == '(' || *arraynext == '{') {
2940
2941 substrend = find_delimiter(arraynext);
2942 arraysave = arraynext + 1;
2943 arraynext = advancetoken(substrend);
2944
2945 newops->type = (u_char)XC_EXPR;
2946 newops->which = P_EXPRESSION; /* placeholder */
2947 }
2948
2949 if (strncmp(arraynext, "pop ", 4)) {
2950 Wprintf("Error: bad expression parameter!\n");
2951 #ifdef TCL_WRAPPER
2952 newops->parameter.expr = strdup("expr 0");
2953 #else
2954 newops->parameter.expr = strdup("0");
2955 #endif
2956 arrayptr = advancetoken(arrayptr);
2957 } else {
2958 *substrend = '\0';
2959 newops->parameter.expr = strdup(arraysave);
2960 arrayptr = advancetoken(arraynext);
2961 }
2962 }
2963
2964 else if (*arrayptr == '(' || *arrayptr == '{') {
2965 float r, g, b;
2966 char *substrend, csave;
2967 stringpart *endpart;
2968
2969 /* type XC_STRING */
2970
2971 substrend = find_delimiter(arrayptr);
2972 csave = *(++substrend);
2973 *substrend = '\0';
2974 if (*arrayptr == '{') arrayptr++;
2975
2976 /* A numerical value immediately following the opening */
2977 /* brace indicates a color parameter. */
2978 if (sscanf(arrayptr, "%f %f %f", &r, &g, &b) == 3) {
2979 newops->type = (u_char)XC_INT;
2980 newops->which = P_COLOR;
2981 newops->parameter.ivalue = rgb_alloccolor((int)(r * 65535),
2982 (int)(g * 65535), (int)(b * 65535));
2983 *substrend = csave;
2984 }
2985 else {
2986 char *arraytmp = arrayptr;
2987 char linkdefault[5] = "(%n)";
2988
2989 newops->type = (u_char)XC_STRING;
2990 newops->which = P_SUBSTRING;
2991 newops->parameter.string = NULL;
2992
2993 /* Quick check for "link" parameter: make object name into "%n" */
2994 if (!strcmp(newops->key, "link"))
2995 if (!strncmp(arrayptr + 1, libobj->name, strlen(libobj->name)) &&
2996 !strcmp(arrayptr + strlen(libobj->name) + 1, ")"))
2997 arraytmp = linkdefault;
2998
2999 readlabel(libobj, arraytmp, &(newops->parameter.string));
3000 *substrend = csave;
3001
3002 /* Append a PARAM_END to the parameter string */
3003
3004 endpart = makesegment(&(newops->parameter.string), NULL);
3005 endpart->type = PARAM_END;
3006 endpart->data.string = (u_char *)NULL;
3007 }
3008 arrayptr = substrend;
3009 while (isspace(*arrayptr) && *arrayptr != '\0')
3010 arrayptr++;
3011 }
3012 else {
3013 /* char *token; (jdk) */
3014 int scanned = 0;
3015
3016 /* type XC_FLOAT or XC_INT, or an indirect reference */
3017
3018 newops->type = (newinst) ? objops->type : (u_char)XC_FLOAT;
3019
3020 if (newops->type == XC_FLOAT) {
3021 scanned = sscanf(arrayptr, "%f", &(newops->parameter.fvalue));
3022 /* Fprintf(stdout, "Object %s called with parameter "
3023 "%s value %g\n", libobj->name,
3024 newops->key, newops->parameter.fvalue); */
3025 }
3026 else if (newops->type == XC_INT) {
3027 scanned = sscanf(arrayptr, "%d", &(newops->parameter.ivalue));
3028 /* Fprintf(stdout, "Object %s called with parameter "
3029 "%s value %d\n", libobj->name,
3030 newops->key, newops->parameter.ivalue); */
3031 }
3032 else if (newops->type == XC_EXPR) {
3033 /* Instance values of parameters hold the last evaluated */
3034 /* result and will be regenerated, so we can ignore them */
3035 /* here. By ignoring it, we don't have to deal with issues */
3036 /* like type promotion. */
3037 free_instance_param(newinst, newops);
3038 scanned = 1; /* avoid treating as an indirect ref */
3039 }
3040 else if (newops->type == XC_STRING) {
3041 /* Fill string record, so we have a valid record. This will */
3042 /* be blown away and replaced by opsubstitute(), but it must */
3043 /* have an initial valid entry. */
3044 stringpart *tmpptr;
3045 newops->parameter.string = NULL;
3046 tmpptr = makesegment(&newops->parameter.string, NULL);
3047 tmpptr->type = TEXT_STRING;
3048 tmpptr = makesegment(&newops->parameter.string, NULL);
3049 tmpptr->type = PARAM_END;
3050 }
3051 else {
3052 Fprintf(stderr, "Error: unknown parameter type!\n");
3053 }
3054
3055 if (scanned == 0) {
3056 /* Indirect reference --- create an eparam in the instance */
3057 parse_ps_string(arrayptr, paramkey, 99, FALSE, TRUE);
3058
3059 if (!newinst || !localdata) {
3060 /* Only object instances can use indirect references */
3061 Fprintf(stderr, "Error: parameter default %s cannot "
3062 "be parsed!\n", paramkey);
3063 }
3064 else if (match_param(localdata, paramkey) == NULL) {
3065 /* Reference key must exist in the calling object */
3066 Fprintf(stderr, "Error: parameter value %s cannot be parsed!\n",
3067 paramkey);
3068 }
3069 else {
3070 /* Create an eparam record in the instance */
3071 eparamptr newepp = make_new_eparam(paramkey);
3072 newepp->flags |= P_INDIRECT;
3073 newepp->pdata.refkey = strdup(newops->key);
3074 newepp->next = newinst->passed;
3075 newinst->passed = newepp;
3076 }
3077
3078 }
3079 arrayptr = advancetoken(arrayptr);
3080 }
3081 }
3082
3083 /* Calculate the unique bounding box for the instance */
3084
3085 if (newinst && (newinst->params != NULL)) {
3086 opsubstitute(libobj, newinst);
3087 calcbboxinst(newinst);
3088 }
3089 }
3090
3091 /*--------------------------------------------------------------*/
3092 /* Read a value which might be a short integer or a parameter. */
3093 /* If the value is a parameter, check the parameter list to see */
3094 /* if it needs to be re-typecast. Return the position to the */
3095 /* next token in "lineptr". */
3096 /*--------------------------------------------------------------*/
3097
3098 char *varpscan(objectptr localdata, char *lineptr, short *hvalue,
3099 genericptr thiselem, int pointno, int offset, u_char which)
3100 {
3101 oparamptr ops = NULL;
3102 char key[100];
3103 /* char *nexttok; (jdk) */
3104 eparamptr newepp;
3105
3106 if (sscanf(lineptr, "%hd", hvalue) != 1) {
3107 parse_ps_string(lineptr, key, 99, FALSE, TRUE);
3108
3109 ops = match_param(localdata, key);
3110 newepp = make_new_eparam(key);
3111
3112 /* Add parameter to the linked list */
3113 newepp->next = thiselem->passed;
3114 thiselem->passed = newepp;
3115 newepp->pdata.pointno = pointno;
3116
3117 if (ops != NULL) {
3118
3119 /* It cannot be known whether a parameter value is a float or int */
3120 /* until we see how the parameter is used. So we always read the */
3121 /* parameter default as a float, and re-typecast it if necessary. */
3122
3123 if (ops->type == XC_FLOAT) {
3124 ops->type = XC_INT;
3125 /* (add 0.1 to avoid roundoff error in conversion to integer) */
3126 ops->parameter.ivalue = (int)(ops->parameter.fvalue +
3127 ((ops->parameter.fvalue < 0) ? -0.1 : 0.1));
3128 }
3129 ops->which = which;
3130 *hvalue = (short)ops->parameter.ivalue;
3131 }
3132 else {
3133 *hvalue = 0; /* okay; will get filled in later */
3134 Fprintf(stderr, "Error: parameter %s was used but not defined!\n", key);
3135 }
3136 }
3137
3138 *hvalue -= (short)offset;
3139
3140 return advancetoken(skipwhitespace(lineptr));
3141 }
3142
3143 /*--------------------------------------------------------------*/
3144 /* Read a value which might be a short integer or a parameter, */
3145 /* but which is not a point in a pointlist. */
3146 /*--------------------------------------------------------------*/
3147
3148 char *varscan(objectptr localdata, char *lineptr, short *hvalue,
3149 genericptr thiselem, u_char which)
3150 {
3151 return varpscan(localdata, lineptr, hvalue, thiselem, 0, 0, which);
3152 }
3153
3154 /*--------------------------------------------------------------*/
3155 /* Read a value which might be a float or a parameter. */
3156 /* Return the position to the next token in "lineptr". */
3157 /*--------------------------------------------------------------*/
3158
3159 char *varfscan(objectptr localdata, char *lineptr, float *fvalue,
3160 genericptr thiselem, u_char which)
3161 {
3162 oparamptr ops = NULL;
3163 eparamptr newepp;
3164 char key[100];
3165
3166 if (sscanf(lineptr, "%f", fvalue) != 1) {
3167 parse_ps_string(lineptr, key, 99, FALSE, TRUE);
3168
3169 /* This bit of a hack takes care of scale-variant */
3170 /* linewidth specifiers for object instances. */
3171
3172 if (!strncmp(key, "/sv", 3)) {
3173 ((objinstptr)thiselem)->style &= ~LINE_INVARIANT;
3174 return varfscan(localdata, advancetoken(skipwhitespace(lineptr)),
3175 fvalue, thiselem, which);
3176 }
3177
3178 ops = match_param(localdata, key);
3179 newepp = make_new_eparam(key);
3180
3181 /* Add parameter to the linked list */
3182 newepp->next = thiselem->passed;
3183 thiselem->passed = newepp;
3184
3185 if (ops != NULL) {
3186 ops->which = which;
3187 *fvalue = ops->parameter.fvalue;
3188 }
3189 else
3190 Fprintf(stderr, "Error: no parameter \"%s\" defined!\n", key);
3191 }
3192
3193 /* advance to next token */
3194 return advancetoken(skipwhitespace(lineptr));
3195 }
3196
3197 /*--------------------------------------------------------------*/
3198 /* Same as varpscan(), but for path types only. */
3199 /*--------------------------------------------------------------*/
3200
3201 char *varpathscan(objectptr localdata, char *lineptr, short *hvalue,
3202 genericptr *thiselem, pathptr thispath, int pointno, int offset,
3203 u_char which, eparamptr *nepptr)
3204 {
3205 oparamptr ops = NULL;
3206 char key[100];
3207 eparamptr newepp;
3208
3209 if (nepptr != NULL) *nepptr = NULL;
3210
3211 if (sscanf(lineptr, "%hd", hvalue) != 1) {
3212 parse_ps_string(lineptr, key, 99, FALSE, TRUE);
3213 ops = match_param(localdata, key);
3214 newepp = make_new_eparam(key);
3215 newepp->pdata.pathpt[1] = pointno;
3216
3217 if (thiselem == NULL)
3218 newepp->pdata.pathpt[0] = (short)0;
3219 else {
3220 short elemidx = (short)(thiselem - thispath->plist);
3221 if (elemidx >= 0 && elemidx < thispath->parts)
3222 newepp->pdata.pathpt[0] = (short)(thiselem - thispath->plist);
3223 else {
3224 Fprintf(stderr, "Error: Bad parameterized path point!\n");
3225 free(newepp);
3226 goto pathdone;
3227 }
3228 }
3229 if (nepptr != NULL) *nepptr = newepp;
3230
3231 /* Add parameter to the linked list. */
3232
3233 newepp->next = thispath->passed;
3234 thispath->passed = newepp;
3235
3236 if (ops != NULL) {
3237
3238 /* It cannot be known whether a parameter value is a float or int */
3239 /* until we see how the parameter is used. So we always read the */
3240 /* parameter default as a float, and re-typecast it if necessary. */
3241
3242 if (ops->type == XC_FLOAT) {
3243 ops->type = XC_INT;
3244 /* (add 0.1 to avoid roundoff error in conversion to integer) */
3245 ops->parameter.ivalue = (int)(ops->parameter.fvalue +
3246 ((ops->parameter.fvalue < 0) ? -0.1 : 0.1));
3247 }
3248 ops->which = which;
3249 *hvalue = (short)ops->parameter.ivalue;
3250 }
3251 else {
3252 *hvalue = 0; /* okay; will get filled in later */
3253 Fprintf(stderr, "Error: parameter %s was used but not defined!\n", key);
3254 }
3255 }
3256
3257 pathdone:
3258 *hvalue -= (short)offset;
3259 return advancetoken(skipwhitespace(lineptr));
3260 }
3261
3262 /*--------------------------------------------------------------*/
3263 /* Create a new instance of an object in the library's list of */
3264 /* instances. This instance will be used on the library page */
3265 /* when doing "composelib()". */
3266 /*--------------------------------------------------------------*/
3267
3268 objinstptr addtoinstlist(int libnum, objectptr libobj, Boolean virtual)
3269 {
3270 objinstptr newinst = (objinstptr) malloc(sizeof(objinst));
3271 liblistptr spec = (liblistptr) malloc(sizeof(liblist));
3272 liblistptr srch;
3273
3274 newinst->type = OBJINST;
3275 instancedefaults(newinst, libobj, 0, 0);
3276
3277 spec->virtual = (u_char)virtual;
3278 spec->thisinst = newinst;
3279 spec->next = NULL;
3280
3281 /* Add to end, so that duplicate, parameterized instances */
3282 /* always come after the original instance with the default */
3283 /* parameters. */
3284
3285 if ((srch = xobjs.userlibs[libnum].instlist) == NULL)
3286 xobjs.userlibs[libnum].instlist = spec;
3287 else {
3288 while (srch->next != NULL) srch = srch->next;
3289 srch->next = spec;
3290 }
3291
3292 /* Calculate the instance-specific bounding box */
3293 calcbboxinst(newinst);
3294
3295 return newinst;
3296 }
3297
3298 /*--------------------------------------------------------------*/
3299 /* Deal with object reads: Create a new object and prepare for */
3300 /* reading. The library number is passed as "mode". */
3301 /*--------------------------------------------------------------*/
3302
3303 objectptr *new_library_object(short mode, char *name, objlistptr *retlist,
3304 TechPtr defaulttech)
3305 {
3306 objlistptr newdef, redef = NULL;
3307 objectptr *newobject, *libobj;
3308 objectptr *curlib = (mode == FONTLIB) ?
3309 xobjs.fontlib.library : xobjs.userlibs[mode - LIBRARY].library;
3310 short *libobjects = (mode == FONTLIB) ?
3311 &xobjs.fontlib.number : &xobjs.userlibs[mode - LIBRARY].number;
3312 int i, j;
3313 char *nsptr, *fullname = name;
3314
3315 curlib = (objectptr *) realloc(curlib, (*libobjects + 1)
3316 * sizeof(objectptr));
3317 if (mode == FONTLIB) xobjs.fontlib.library = curlib;
3318 else xobjs.userlibs[mode - LIBRARY].library = curlib;
3319
3320 /* For (older) libraries that do not use technologies, give the */
3321 /* object a technology name in the form <library>::<object> */
3322
3323 if ((nsptr = strstr(name, "::")) == NULL) {
3324 int deftechlen = (defaulttech == NULL) ? 0 : strlen(defaulttech->technology);
3325 fullname = (char *)malloc(deftechlen + strlen(name) + 3);
3326 if (defaulttech == NULL)
3327 sprintf(fullname, "::%s", name);
3328 else
3329 sprintf(fullname, "%s::%s", defaulttech->technology, name);
3330 }
3331
3332 /* initial 1-pointer allocations */
3333
3334 newobject = curlib + (*libobjects);
3335 *newobject = (objectptr) malloc(sizeof(object));
3336 initmem(*newobject);
3337
3338 /* check that this object is not already in list of objects */
3339
3340 if (mode == FONTLIB) {
3341 for (libobj = xobjs.fontlib.library; libobj != xobjs.fontlib.library +
3342 xobjs.fontlib.number; libobj++) {
3343 /* This font character may be a redefinition of another */
3344 if (!objnamecmp(fullname, (*libobj)->name)) {
3345 newdef = (objlistptr) malloc(sizeof(objlist));
3346 newdef->libno = FONTLIB;
3347 newdef->thisobject = *libobj;
3348 newdef->next = redef;
3349 redef = newdef;
3350 }
3351 }
3352 }
3353 else {
3354 for (i = 0; i < xobjs.numlibs; i++) {
3355 for (j = 0; j < xobjs.userlibs[i].number; j++) {
3356 libobj = xobjs.userlibs[i].library + j;
3357 /* This object may be a redefinition of another object */
3358 if (!objnamecmp(fullname, (*libobj)->name)) {
3359 newdef = (objlistptr) malloc(sizeof(objlist));
3360 newdef->libno = i + LIBRARY;
3361 newdef->thisobject = *libobj;
3362 newdef->next = redef;
3363 redef = newdef;
3364 }
3365 }
3366 }
3367 }
3368
3369 (*libobjects)++;
3370 sprintf((*newobject)->name, "%s", fullname);
3371 if (fullname != name) free(fullname);
3372
3373 /* initmem() initialized schemtype to PRIMARY; change it. */
3374 (*newobject)->schemtype = (mode == FONTLIB) ? GLYPH : SYMBOL;
3375
3376 /* If the object declares a technology name that is different from the */
3377 /* default, then add the technology name to the list of technologies, */
3378 /* with a NULL filename. */
3379
3380 if (mode != FONTLIB) AddObjectTechnology(*newobject);
3381
3382 *retlist = redef;
3383 return newobject;
3384 }
3385
3386 /*--------------------------------------------------------------*/
3387 /* do an exhaustive comparison between a new object and any */
3388 /* object having the same name. If they are the same, destroy */
3389 /* the duplicate. If different, rename the original one. */
3390 /*--------------------------------------------------------------*/
3391
3392 Boolean library_object_unique(short mode, objectptr newobject, objlistptr redef)
3393 {
3394 Boolean is_unique = True;
3395 objlistptr newdef;
3396 short *libobjects = (mode == FONTLIB) ?
3397 &xobjs.fontlib.number : &xobjs.userlibs[mode - LIBRARY].number;
3398
3399 if (redef == NULL)
3400 return is_unique; /* No name conflicts; object is okay as-is */
3401
3402 for (newdef = redef; newdef != NULL; newdef = newdef->next) {
3403
3404 /* Must make sure that default parameter values are */
3405 /* plugged into both objects! */
3406 opsubstitute(newdef->thisobject, NULL);
3407 opsubstitute(newobject, NULL);
3408
3409 if (objcompare(newobject, newdef->thisobject) == True) {
3410 addalias(newdef->thisobject, newobject->name);
3411
3412 /* If the new object has declared an association to a */
3413 /* schematic, transfer it to the original, and make */
3414 /* sure that the page points to the object which will */
3415 /* be left, not the one which will be destroyed. */
3416
3417 if (newobject->symschem != NULL) {
3418 newdef->thisobject->symschem = newobject->symschem;
3419 newdef->thisobject->symschem->symschem = newdef->thisobject;
3420 }
3421
3422 reset(newobject, DESTROY);
3423 (*libobjects)--;
3424 is_unique = False;
3425 break;
3426 }
3427
3428 /* Not the same object, but has the same name. This can't */
3429 /* happen within the same input file, so the name of the */
3430 /* original object can safely be altered. */
3431
3432 else if (!strcmp(newobject->name, newdef->thisobject->name)) {
3433
3434 /* Replacement---for project management, allow the technology */
3435 /* master version to take precedence over a local version. */
3436
3437 TechPtr nsptr = GetObjectTechnology(newobject);
3438
3439 if (nsptr && (nsptr->flags & TECH_REPLACE)) {
3440 reset(newobject, DESTROY);
3441 (*libobjects)--;
3442 is_unique = False;
3443 }
3444 else
3445 checkname(newdef->thisobject);
3446 break;
3447 }
3448 }
3449 for (; (newdef = redef->next); redef = newdef)
3450 free(redef);
3451 free(redef);
3452
3453 return is_unique;
3454 }
3455
3456 /*--------------------------------------------------------------*/
3457 /* Add an instance of the object to the library's instance list */
3458 /*--------------------------------------------------------------*/
3459
3460 void add_object_to_library(short mode, objectptr newobject)
3461 {
3462 objinstptr libinst;
3463
3464 if (mode == FONTLIB) return;
3465
3466 libinst = addtoinstlist(mode - LIBRARY, newobject, False);
3467 calcbboxvalues(libinst, (genericptr *)NULL);
3468
3469 /* Center the view of the object in its instance */
3470 centerview(libinst);
3471 }
3472
3473 /*--------------------------------------------------------------*/
3474 /* Continuation Line --- add memory to "buffer" as necessary. */
3475 /* Add a space character to the current text in "buffer" and */
3476 /* return a pointer to the new end-of-text. */
3477 /*--------------------------------------------------------------*/
3478
3479 char *continueline(char **buffer)
3480 {
3481 char *lineptr;
3482 int bufsize;
3483
3484 for (lineptr = *buffer; (*lineptr != '\n') && (*lineptr != '\0'); lineptr++);
3485 /* Repair Windoze-mangled files */
3486 if ((lineptr > *buffer) && (*lineptr == '\n') && (*(lineptr - 1) == '\r'))
3487 *(lineptr - 1) = ' ';
3488 if (*lineptr == '\n') *lineptr++ = ' ';
3489
3490 bufsize = (int)(lineptr - (*buffer)) + 256;
3491 *buffer = (char *)realloc((*buffer), bufsize * sizeof(char));
3492
3493 return ((*buffer) + (bufsize - 256));
3494 }
3495
3496 /*--------------------------------------------------------------*/
3497 /* Read image data out of the Setup block of the input */
3498 /* We assume that width and height have been parsed from the */
3499 /* "imagedata" line and the file pointer is at the next line. */
3500 /*--------------------------------------------------------------*/
3501
3502 void readimagedata(FILE *ps, int width, int height)
3503 {
3504 char temp[150], ascbuf[6];
3505 int x, y, p, q, r, g, b, ilen;
3506 char *pptr;
3507 Imagedata *iptr;
3508 Boolean do_flate = False, do_ascii = False;
3509 u_char *filtbuf, *flatebuf;
3510 union {
3511 u_char b[4];
3512 u_long i;
3513 } pixel;
3514
3515 iptr = addnewimage(NULL, width, height);
3516
3517 /* Read the image data */
3518
3519 fgets(temp, 149, ps);
3520 if (strstr(temp, "ASCII85Decode") != NULL) do_ascii = TRUE;
3521 #ifdef HAVE_LIBZ
3522 if (strstr(temp, "FlateDecode") != NULL) do_flate = TRUE;
3523 #else
3524 if (strstr(temp, "FlateDecode") != NULL)
3525 Fprintf(stderr, "Error: Don't know how to Flate decode!"
3526 " Get zlib and recompile xcircuit!\n");
3527 #endif
3528 while (strstr(temp, "ReusableStreamDecode") == NULL)
3529 fgets(temp, 149, ps); /* Additional piped filter lines */
3530
3531 fgets(temp, 149, ps); /* Initial data line */
3532 q = 0;
3533 pptr = temp;
3534 ilen = 3 * width * height;
3535 filtbuf = (u_char *)malloc(ilen + 4);
3536
3537 if (!do_ascii) { /* ASCIIHexDecode algorithm */
3538 q = 0;
3539 for (y = 0; y < height; y++) {
3540 for (x = 0; x < width; x++) {
3541 sscanf(pptr, "%02x%02x%02x", &r, &g, &b);
3542 filtbuf[q++] = (u_char)r;
3543 filtbuf[q++] = (u_char)g;
3544 filtbuf[q++] = (u_char)b;
3545 pptr += 6;
3546 if (*pptr == '\n') {
3547 fgets(temp, 149, ps);
3548 pptr = temp;
3549 }
3550 }
3551 }
3552 }
3553 else { /* ASCII85Decode algorithm */
3554 p = 0;
3555 while (1) {
3556 ascbuf[0] = *pptr;
3557 pptr++;
3558 if (ascbuf[0] == '~')
3559 break;
3560 else if (ascbuf[0] == 'z') {
3561 for (y = 0; y < 5; y++) ascbuf[y] = '\0';
3562 }
3563 else {
3564 for (y = 1; y < 5; y++) {
3565 if (*pptr == '\n') {
3566 fgets(temp, 149, ps);
3567 pptr = temp;
3568 }
3569 ascbuf[y] = *pptr;
3570 if (ascbuf[y] == '~') {
3571 for (; y < 5; y++) {
3572 ascbuf[y] = '!';
3573 p++;
3574 }
3575 break;
3576 }
3577 else pptr++;
3578 }
3579 for (y = 0; y < 5; y++) ascbuf[y] -= '!';
3580 }
3581
3582 if (*pptr == '\n') {
3583 fgets(temp, 149, ps);
3584 pptr = temp;
3585 }
3586
3587 /* Decode from ASCII85 to binary */
3588
3589 pixel.i = ascbuf[4] + ascbuf[3] * 85 + ascbuf[2] * 7225 +
3590 ascbuf[1] * 614125 + ascbuf[0] * 52200625;
3591
3592 /* Add in roundoff for final bytes */
3593 if (p > 0) {
3594 switch (p) {
3595 case 3:
3596 pixel.i += 0xff0000;
3597 case 2:
3598 pixel.i += 0xff00;
3599 case 1:
3600 pixel.i += 0xff;
3601 }
3602 }
3603
3604 for (y = 0; y < (4 - p); y++) {
3605 filtbuf[q + y] = pixel.b[3 - y];
3606 }
3607 q += (4 - p);
3608 if (q >= ilen) break;
3609 }
3610 }
3611
3612 /* Extra decoding goes here */
3613
3614 #ifdef HAVE_LIBZ
3615 if (do_flate) {
3616 flatebuf = (char *)malloc(ilen);
3617 large_inflate(filtbuf, q, &flatebuf, ilen);
3618 free(filtbuf);
3619 }
3620 else
3621 #endif
3622
3623 flatebuf = filtbuf;
3624
3625 q = 0;
3626 for (y = 0; y < height; y++)
3627 for (x = 0; x < width; x++) {
3628 u_char r, g, b;
3629 r = flatebuf[q++];
3630 g = flatebuf[q++];
3631 b = flatebuf[q++];
3632 xcImagePutPixel(iptr->image, x, y, r, g, b);
3633 }
3634
3635 free(flatebuf);
3636
3637 fgets(temp, 149, ps); /* definition line */
3638 fgets(temp, 149, ps); /* pick up name of image from here */
3639 for (pptr = temp; !isspace(*pptr); pptr++);
3640 *pptr = '\0';
3641 iptr->filename = strdup(temp + 1);
3642 for (x = 0; x < 5; x++) fgets(temp, 149, ps); /* skip image dictionary */
3643 }
3644
3645 /*--------------------------------------------------------------*/
3646 /* Read an object (page) from a file into xcircuit */
3647 /*--------------------------------------------------------------*/
3648
3649 Boolean objectread(FILE *ps, objectptr localdata, short offx, short offy,
3650 short mode, char *retstr, int ccolor, TechPtr defaulttech)
3651 {
3652 char *temp, *buffer, keyword[80];
3653 short tmpfont = -1;
3654 float tmpscale = 0.0;
3655 objectptr *libobj;
3656 int curcolor = ccolor;
3657 char *colorkey = NULL;
3658 char *widthkey = NULL;
3659 int i, j, k;
3660 short px, py;
3661 objinstptr *newinst;
3662 eparamptr epptrx, epptry; /* used for paths only */
3663
3664 /* path-handling variables */
3665 pathptr *newpath;
3666 XPoint startpoint;
3667
3668 keyword[0] = '\0';
3669
3670 buffer = (char *)malloc(256 * sizeof(char));
3671 temp = buffer;
3672
3673 for(;;) {
3674 char *lineptr, *keyptr, *saveptr;
3675
3676 if (fgets(temp, 255, ps) == NULL) {
3677 if (strcmp(keyword, "restore")) {
3678 Wprintf("Error: end of file.");
3679 *retstr = '\0';
3680 }
3681 break;
3682 }
3683 temp = buffer;
3684
3685 /* because PostScript is a stack language, we will scan from the end */
3686 for (lineptr = buffer; (*lineptr != '\n') && (*lineptr != '\0'); lineptr++);
3687 /* Avoid CR-LF at EOL added by stupid Windoze programs */
3688 if ((lineptr > buffer) && *(lineptr - 1) == '\r') lineptr--;
3689 if (lineptr != buffer) { /* ignore any blank lines */
3690 for (keyptr = lineptr - 1; isspace(*keyptr) && keyptr != buffer; keyptr--);
3691 for (; !isspace(*keyptr) && keyptr != buffer; keyptr--);
3692 sscanf(keyptr, "%79s", keyword);
3693
3694 if (!strcmp(keyword, "showpage")) {
3695 strncpy(retstr, buffer, 150);
3696 retstr[149] = '\0';
3697 free(buffer);
3698
3699 /* If we have just read a schematic that is attached */
3700 /* to a symbol, check all of the pin labels in the symbol */
3701 /* to see if they correspond to pin names in the schematic. */
3702 /* The other way around (pin in schematic with no */
3703 /* corresponding name in the symbol) is not an error. */
3704
3705 if (localdata->symschem != NULL) {
3706 genericptr *pgen, *lgen;
3707 labelptr plab, lcmp;
3708 for (pgen = localdata->symschem->plist; pgen < localdata->
3709 symschem->plist + localdata->symschem->parts; pgen++) {
3710 if (IS_LABEL(*pgen)) {
3711 plab = TOLABEL(pgen);
3712 if (plab->pin == LOCAL) {
3713 for (lgen = localdata->plist; lgen < localdata->plist +
3714 localdata->parts; lgen++) {
3715 if (IS_LABEL(*lgen)) {
3716 lcmp = TOLABEL(lgen);
3717 if (lcmp->pin == LOCAL)
3718 if (!stringcomprelaxed(lcmp->string, plab->string,
3719 areawin->topinstance))
3720 break;
3721 }
3722 }
3723 if (lgen == localdata->plist + localdata->parts) {
3724 char *cptr, *d1ptr, *d2ptr;
3725 char *pch = textprint(plab->string, areawin->topinstance);
3726
3727 /* Check for likely delimiters before applying warning */
3728
3729 if ((cptr = strchr(pch, ':')) != NULL) {
3730 d1ptr = strchr(pch, '[');
3731 d2ptr = strchr(pch, ']');
3732 if (d1ptr != NULL && d2ptr != NULL &&
3733 d1ptr < cptr && d2ptr > cptr) {
3734 if (areawin->buschar != '[') {
3735 areawin->buschar = '[';
3736 Fprintf(stderr, "Warning: Bus character \'[\'"
3737 " apparently used but not declared.\n");
3738 }
3739 }
3740 d1ptr = strchr(pch, '{');
3741 d2ptr = strchr(pch, '}');
3742 if (d1ptr != NULL && d2ptr != NULL &&
3743 d1ptr < cptr && d2ptr > cptr) {
3744 if (areawin->buschar != '{') {
3745 areawin->buschar = '{';
3746 Fprintf(stderr, "Warning: Bus character \'{\'"
3747 " apparently used in pin \"%s\""
3748 " but not declared.\n", pch);
3749 }
3750 }
3751 d1ptr = strchr(pch, '<');
3752 d2ptr = strchr(pch, '>');
3753 if (d1ptr != NULL && d2ptr != NULL &&
3754 d1ptr < cptr && d2ptr > cptr) {
3755 if (areawin->buschar != '<') {
3756 areawin->buschar = '<';
3757 Fprintf(stderr, "Warning: Bus character \'<\'"
3758 " apparently used in pin \"%s\""
3759 " but not declared.\n", pch);
3760 }
3761 }
3762 d1ptr = strchr(pch, '(');
3763 d2ptr = strchr(pch, ')');
3764 if (d1ptr != NULL && d2ptr != NULL &&
3765 d1ptr < cptr && d2ptr > cptr) {
3766 if (areawin->buschar != '(') {
3767 areawin->buschar = '(';
3768 Fprintf(stderr, "Warning: Bus character \'(\'"
3769 " apparently used in pin \"%s\""
3770 " but not declared.\n", pch);
3771 }
3772 }
3773 }
3774 else
3775 Fprintf(stderr, "Warning: Unattached pin \"%s\" in "
3776 "symbol %s\n", pch,
3777 localdata->symschem->name);
3778 free(pch);
3779 }
3780 }
3781 }
3782 }
3783 }
3784 return False; /* end of page */
3785 }
3786
3787 /* make a color change, adding the color if necessary */
3788
3789 else if (!strcmp(keyword, "scb")) {
3790 float red, green, blue;
3791 if (sscanf(buffer, "%f %f %f", &red, &green, &blue) == 3) {
3792 curcolor = rgb_alloccolor((int)(red * 65535), (int)(green * 65535),
3793 (int)(blue * 65535));
3794 colorkey = NULL;
3795 }
3796 else {
3797 char tmpkey[30];
3798 oparamptr ops;
3799
3800 parse_ps_string(buffer, tmpkey, 29, FALSE, TRUE);
3801 ops = match_param(localdata, tmpkey);
3802 if (ops != NULL) {
3803 /* Recast expression parameter, if necessary */
3804 if (ops->which == P_EXPRESSION) ops->which = P_COLOR;
3805 if (ops->which == P_COLOR) {
3806 colorkey = ops->key;
3807 switch (ops->type) {
3808 case XC_INT:
3809 curcolor = ops->parameter.ivalue;
3810 break;
3811 default:
3812 curcolor = DEFAULTCOLOR; /* placeholder */
3813 break;
3814 }
3815 }
3816 }
3817 }
3818 }
3819
3820 /* end the color change, returning to default */
3821
3822 else if (!strcmp(keyword, "sce")) {
3823 curcolor = ccolor;
3824 colorkey = NULL;
3825 }
3826
3827 /* begin a path constructor */
3828
3829 else if (!strcmp(keyword, "beginpath")) {
3830 px = py = 0;
3831
3832 NEW_PATH(newpath, localdata);
3833 (*newpath)->plist = (genericptr *)malloc(sizeof(genericptr));
3834 (*newpath)->parts = 0;
3835 (*newpath)->color = curcolor;
3836 (*newpath)->passed = NULL;
3837
3838 for (--keyptr; *keyptr == ' '; keyptr--);
3839 for (; *keyptr != ' '; keyptr--);
3840
3841 /* check for "addtox" and "addtoy" parameter specification */
3842 while (!strncmp(keyptr + 1, "addto", 5)) {
3843 saveptr = keyptr + 1;
3844
3845 for (--keyptr; *keyptr == ' '; keyptr--);
3846 for (; *keyptr != ' '; keyptr--);
3847
3848 /* Get parameter and its value */
3849 if (*(saveptr + 5) == 'x')
3850 varpscan(localdata, keyptr + 1, &px, (genericptr)*newpath,
3851 -1, offx, P_POSITION_X);
3852 else
3853 varpscan(localdata, keyptr + 1, &py, (genericptr)*newpath,
3854 -1, offy, P_POSITION_Y);
3855
3856 for (--keyptr; *keyptr == ' '; keyptr--);
3857 for (; *keyptr != ' '; keyptr--);
3858 }
3859
3860 lineptr = varpathscan(localdata, buffer, &startpoint.x,
3861 (genericptr *)NULL, *newpath, 0, offx + px, P_POSITION_X,
3862 &epptrx);
3863 lineptr = varpathscan(localdata, lineptr, &startpoint.y,
3864 (genericptr *)NULL, *newpath, 0, offy + py, P_POSITION_Y,
3865 &epptry);
3866
3867 std_eparam((genericptr)(*newpath), colorkey);
3868 }
3869
3870 /* end the path constructor */
3871
3872 else if (!strcmp(keyword, "endpath")) {
3873
3874 lineptr = varscan(localdata, buffer, &(*newpath)->style,
3875 (genericptr)*newpath, P_STYLE);
3876 lineptr = varfscan(localdata, lineptr, &(*newpath)->width,
3877 (genericptr)*newpath, P_LINEWIDTH);
3878
3879 if ((*newpath)->parts <= 0) { /* in case of an empty path */
3880 free((*newpath)->plist);
3881 free(*newpath);
3882 localdata->parts--;
3883 }
3884 newpath = NULL;
3885 }
3886
3887 /* read path parts */
3888
3889 else if (!strcmp(keyword, "polyc")) {
3890 polyptr *newpoly;
3891 pointlist newpoints;
3892 short tmpnum;
3893
3894 px = py = 0;
3895
3896 NEW_POLY(newpoly, (*newpath));
3897
3898 for (--keyptr; *keyptr == ' '; keyptr--);
3899 for (; *keyptr != ' '; keyptr--);
3900
3901 /* check for "addtox" and "addtoy" parameter specification */
3902 while (!strncmp(keyptr + 1, "addto", 5)) {
3903 saveptr = keyptr + 1;
3904
3905 for (--keyptr; *keyptr == ' '; keyptr--);
3906 for (; *keyptr != ' '; keyptr--);
3907
3908 /* Get parameter and its value */
3909 if (*(saveptr + 5) == 'x')
3910 varpscan(localdata, keyptr + 1, &px, (genericptr)*newpoly,
3911 -1, offx, P_POSITION_X);
3912 else
3913 varpscan(localdata, keyptr + 1, &py, (genericptr)*newpoly,
3914 -1, offy, P_POSITION_Y);
3915
3916 for (--keyptr; *keyptr == ' '; keyptr--);
3917 for (; *keyptr != ' '; keyptr--);
3918 }
3919
3920 sscanf(keyptr, "%hd", &tmpnum);
3921 (*newpoly)->number = tmpnum + 1;
3922 (*newpoly)->width = 1.0;
3923 (*newpoly)->style = UNCLOSED;
3924 (*newpoly)->color = curcolor;
3925 (*newpoly)->passed = NULL;
3926 (*newpoly)->cycle = NULL;
3927
3928 (*newpoly)->points = (pointlist) malloc((*newpoly)->number *
3929 sizeof(XPoint));
3930
3931 /* If the last point on the last path part was parameterized, then */
3932 /* the first point of the spline must be, too. */
3933
3934 if (epptrx != NULL) {
3935 eparamptr newepp = copyeparam(epptrx, (genericptr)(*newpath));
3936 newepp->next = (*newpath)->passed;
3937 (*newpath)->passed = newepp;
3938 newepp->pdata.pathpt[1] = 0;
3939 newepp->pdata.pathpt[0] = (*newpath)->parts - 1;
3940 }
3941 if (epptry != NULL) {
3942 eparamptr newepp = copyeparam(epptry, (genericptr)(*newpath));
3943 newepp->next = (*newpath)->passed;
3944 (*newpath)->passed = newepp;
3945 newepp->pdata.pathpt[1] = 0;
3946 newepp->pdata.pathpt[0] = (*newpath)->parts - 1;
3947 }
3948
3949 lineptr = buffer;
3950
3951 newpoints = (*newpoly)->points + (*newpoly)->number - 1;
3952 lineptr = varpathscan(localdata, lineptr, &newpoints->x,
3953 (genericptr *)newpoly, *newpath, newpoints - (*newpoly)->points,
3954 offx + px, P_POSITION_X, &epptrx);
3955 lineptr = varpathscan(localdata, lineptr, &newpoints->y,
3956 (genericptr *)newpoly, *newpath, newpoints - (*newpoly)->points,
3957 offy + py, P_POSITION_Y, &epptry);
3958
3959 for (--newpoints; newpoints > (*newpoly)->points; newpoints--) {
3960
3961 lineptr = varpathscan(localdata, lineptr, &newpoints->x,
3962 (genericptr *)newpoly, *newpath, newpoints - (*newpoly)->points,
3963 offx + px, P_POSITION_X, NULL);
3964 lineptr = varpathscan(localdata, lineptr, &newpoints->y,
3965 (genericptr *)newpoly, *newpath, newpoints - (*newpoly)->points,
3966 offy + py, P_POSITION_Y, NULL);
3967 }
3968 newpoints->x = startpoint.x;
3969 newpoints->y = startpoint.y;
3970 startpoint.x = (newpoints + (*newpoly)->number - 1)->x;
3971 startpoint.y = (newpoints + (*newpoly)->number - 1)->y;
3972 }
3973
3974 else if (!strcmp(keyword, "arc") || !strcmp(keyword, "arcn")) {
3975 arcptr *newarc;
3976 NEW_ARC(newarc, (*newpath));
3977 (*newarc)->width = 1.0;
3978 (*newarc)->style = UNCLOSED;
3979 (*newarc)->color = curcolor;
3980 (*newarc)->passed = NULL;
3981 (*newarc)->cycle = NULL;
3982
3983 lineptr = varpscan(localdata, buffer, &(*newarc)->position.x,
3984 (genericptr)*newarc, 0, offx, P_POSITION_X);
3985 lineptr = varpscan(localdata, lineptr, &(*newarc)->position.y,
3986 (genericptr)*newarc, 0, offy, P_POSITION_Y);
3987 lineptr = varscan(localdata, lineptr, &(*newarc)->radius,
3988 (genericptr)*newarc, P_RADIUS);
3989 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle1,
3990 (genericptr)*newarc, P_ANGLE1);
3991 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle2,
3992 (genericptr)*newarc, P_ANGLE2);
3993
3994 (*newarc)->yaxis = (*newarc)->radius;
3995 if (!strcmp(keyword, "arcn")) {
3996 float tmpang = (*newarc)->angle1;
3997 (*newarc)->radius = -((*newarc)->radius);
3998 (*newarc)->angle1 = (*newarc)->angle2;
3999 (*newarc)->angle2 = tmpang;
4000 }
4001
4002 calcarc(*newarc);
4003 startpoint.x = (short)(*newarc)->points[(*newarc)->number - 1].x;
4004 startpoint.y = (short)(*newarc)->points[(*newarc)->number - 1].y;
4005 decomposearc(*newpath);
4006 }
4007
4008 else if (!strcmp(keyword, "pellip") || !strcmp(keyword, "nellip")) {
4009 arcptr *newarc;
4010 NEW_ARC(newarc, (*newpath));
4011 (*newarc)->width = 1.0;
4012 (*newarc)->style = UNCLOSED;
4013 (*newarc)->color = curcolor;
4014 (*newarc)->passed = NULL;
4015 (*newarc)->cycle = NULL;
4016
4017 lineptr = varpscan(localdata, buffer, &(*newarc)->position.x,
4018 (genericptr)*newarc, 0, offx, P_POSITION_X);
4019 lineptr = varpscan(localdata, lineptr, &(*newarc)->position.y,
4020 (genericptr)*newarc, 0, offy, P_POSITION_Y);
4021 lineptr = varscan(localdata, lineptr, &(*newarc)->radius,
4022 (genericptr)*newarc, P_RADIUS);
4023 lineptr = varscan(localdata, lineptr, &(*newarc)->yaxis,
4024 (genericptr)*newarc, P_MINOR_AXIS);
4025 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle1,
4026 (genericptr)*newarc, P_ANGLE1);
4027 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle2,
4028 (genericptr)*newarc, P_ANGLE2);
4029
4030 if (!strcmp(keyword, "nellip")) {
4031 float tmpang = (*newarc)->angle1;
4032 (*newarc)->radius = -((*newarc)->radius);
4033 (*newarc)->angle1 = (*newarc)->angle2;
4034 (*newarc)->angle2 = tmpang;
4035
4036 }
4037 calcarc(*newarc);
4038 startpoint.x = (short)(*newarc)->points[(*newarc)->number - 1].x;
4039 startpoint.y = (short)(*newarc)->points[(*newarc)->number - 1].y;
4040 decomposearc(*newpath);
4041 }
4042
4043 else if (!strcmp(keyword, "curveto")) {
4044 splineptr *newspline;
4045 px = py = 0;
4046
4047 NEW_SPLINE(newspline, (*newpath));
4048 (*newspline)->passed = NULL;
4049 (*newspline)->cycle = NULL;
4050 (*newspline)->width = 1.0;
4051 (*newspline)->style = UNCLOSED;
4052 (*newspline)->color = curcolor;
4053
4054 /* If the last point on the last path part was parameterized, then */
4055 /* the first point of the spline must be, too. */
4056
4057 if (epptrx != NULL) {
4058 eparamptr newepp = copyeparam(epptrx, (genericptr)(*newpath));
4059 newepp->next = (*newpath)->passed;
4060 (*newpath)->passed = newepp;
4061 newepp->pdata.pathpt[1] = 0;
4062 newepp->pdata.pathpt[0] = (*newpath)->parts - 1;
4063 }
4064 if (epptry != NULL) {
4065 eparamptr newepp = copyeparam(epptry, (genericptr)(*newpath));
4066 newepp->next = (*newpath)->passed;
4067 (*newpath)->passed = newepp;
4068 newepp->pdata.pathpt[1] = 0;
4069 newepp->pdata.pathpt[0] = (*newpath)->parts - 1;
4070 }
4071
4072 for (--keyptr; *keyptr == ' '; keyptr--);
4073 for (; *keyptr != ' '; keyptr--);
4074
4075 /* check for "addtox" and "addtoy" parameter specification */
4076 while (!strncmp(keyptr + 1, "addto", 5)) {
4077 saveptr = keyptr + 1;
4078
4079 for (--keyptr; *keyptr == ' '; keyptr--);
4080 for (; *keyptr != ' '; keyptr--);
4081
4082 /* Get parameter and its value */
4083 if (*(saveptr + 5) == 'x')
4084 varpscan(localdata, keyptr + 1, &px, (genericptr)*newspline,
4085 -1, offx, P_POSITION_X);
4086 else
4087 varpscan(localdata, keyptr + 1, &py, (genericptr)*newspline,
4088 -1, offy, P_POSITION_Y);
4089
4090 for (--keyptr; *keyptr == ' '; keyptr--);
4091 for (; *keyptr != ' '; keyptr--);
4092 }
4093
4094
4095 lineptr = varpathscan(localdata, buffer, &(*newspline)->ctrl[1].x,
4096 (genericptr *)newspline, *newpath, 1, offx + px, P_POSITION_X,
4097 NULL);
4098 lineptr = varpathscan(localdata, lineptr, &(*newspline)->ctrl[1].y,
4099 (genericptr *)newspline, *newpath, 1, offy + py, P_POSITION_Y,
4100 NULL);
4101 lineptr = varpathscan(localdata, lineptr, &(*newspline)->ctrl[2].x,
4102 (genericptr *)newspline, *newpath, 2, offx + px, P_POSITION_X,
4103 NULL);
4104 lineptr = varpathscan(localdata, lineptr, &(*newspline)->ctrl[2].y,
4105 (genericptr *)newspline, *newpath, 2, offy + py, P_POSITION_Y,
4106 NULL);
4107 lineptr = varpathscan(localdata, lineptr, &(*newspline)->ctrl[3].x,
4108 (genericptr *)newspline, *newpath, 3, offx + px, P_POSITION_X,
4109 &epptrx);
4110 lineptr = varpathscan(localdata, lineptr, &(*newspline)->ctrl[3].y,
4111 (genericptr *)newspline, *newpath, 3, offy + py, P_POSITION_Y,
4112 &epptry);
4113
4114 (*newspline)->ctrl[0].x = startpoint.x;
4115 (*newspline)->ctrl[0].y = startpoint.y;
4116
4117 calcspline(*newspline);
4118 startpoint.x = (*newspline)->ctrl[3].x;
4119 startpoint.y = (*newspline)->ctrl[3].y;
4120 }
4121
4122 /* read arcs */
4123
4124 else if (!strcmp(keyword, "xcarc")) {
4125 arcptr *newarc;
4126
4127 NEW_ARC(newarc, localdata);
4128 (*newarc)->color = curcolor;
4129 (*newarc)->passed = NULL;
4130 (*newarc)->cycle = NULL;
4131
4132 /* backward compatibility */
4133 if (version < 1.5) {
4134 sscanf(buffer, "%hd %hd %hd %f %f %f %hd", &(*newarc)->position.x,
4135 &(*newarc)->position.y, &(*newarc)->radius, &(*newarc)->angle1,
4136 &(*newarc)->angle2, &(*newarc)->width, &(*newarc)->style);
4137 (*newarc)->position.x -= offx;
4138 (*newarc)->position.y -= offy;
4139 }
4140 else {
4141 lineptr = varscan(localdata, buffer, &(*newarc)->style,
4142 (genericptr)*newarc, P_STYLE);
4143 lineptr = varfscan(localdata, lineptr, &(*newarc)->width,
4144 (genericptr)*newarc, P_LINEWIDTH);
4145 lineptr = varpscan(localdata, lineptr, &(*newarc)->position.x,
4146 (genericptr)*newarc, 0, offx, P_POSITION_X);
4147 lineptr = varpscan(localdata, lineptr, &(*newarc)->position.y,
4148 (genericptr)*newarc, 0, offy, P_POSITION_Y);
4149 lineptr = varscan(localdata, lineptr, &(*newarc)->radius,
4150 (genericptr)*newarc, P_RADIUS);
4151 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle1,
4152 (genericptr)*newarc, P_ANGLE1);
4153 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle2,
4154 (genericptr)*newarc, P_ANGLE2);
4155 }
4156
4157 (*newarc)->yaxis = (*newarc)->radius;
4158 calcarc(*newarc);
4159 std_eparam((genericptr)(*newarc), colorkey);
4160 }
4161
4162 /* read ellipses */
4163
4164 else if (!strcmp(keyword, "ellipse")) {
4165 arcptr *newarc;
4166
4167 NEW_ARC(newarc, localdata);
4168
4169 (*newarc)->color = curcolor;
4170 (*newarc)->passed = NULL;
4171 (*newarc)->cycle = NULL;
4172
4173 lineptr = varscan(localdata, buffer, &(*newarc)->style,
4174 (genericptr)*newarc, P_STYLE);
4175 lineptr = varfscan(localdata, lineptr, &(*newarc)->width,
4176 (genericptr)*newarc, P_LINEWIDTH);
4177 lineptr = varpscan(localdata, lineptr, &(*newarc)->position.x,
4178 (genericptr)*newarc, 0, offx, P_POSITION_X);
4179 lineptr = varpscan(localdata, lineptr, &(*newarc)->position.y,
4180 (genericptr)*newarc, 0, offy, P_POSITION_Y);
4181 lineptr = varscan(localdata, lineptr, &(*newarc)->radius,
4182 (genericptr)*newarc, P_RADIUS);
4183 lineptr = varscan(localdata, lineptr, &(*newarc)->yaxis,
4184 (genericptr)*newarc, P_MINOR_AXIS);
4185 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle1,
4186 (genericptr)*newarc, P_ANGLE1);
4187 lineptr = varfscan(localdata, lineptr, &(*newarc)->angle2,
4188 (genericptr)*newarc, P_ANGLE2);
4189
4190 calcarc(*newarc);
4191 std_eparam((genericptr)(*newarc), colorkey);
4192 }
4193
4194 /* read polygons */
4195 /* (and wires---backward compatibility for v1.5 and earlier) */
4196
4197 else if (!strcmp(keyword, "polygon") || !strcmp(keyword, "wire")) {
4198 polyptr *newpoly;
4199 pointlist newpoints;
4200 px = py = 0;
4201
4202 NEW_POLY(newpoly, localdata);
4203 lineptr = buffer;
4204
4205 (*newpoly)->passed = NULL;
4206 (*newpoly)->cycle = NULL;
4207
4208 if (!strcmp(keyword, "wire")) {
4209 (*newpoly)->number = 2;
4210 (*newpoly)->width = 1.0;
4211 (*newpoly)->style = UNCLOSED;
4212 }
4213 else {
4214 /* backward compatibility */
4215 if (version < 1.5) {
4216 for (--keyptr; *keyptr == ' '; keyptr--);
4217 for (; *keyptr != ' '; keyptr--);
4218 sscanf(keyptr, "%hd", &(*newpoly)->style);
4219 for (--keyptr; *keyptr == ' '; keyptr--);
4220 for (; *keyptr != ' '; keyptr--);
4221 sscanf(keyptr, "%f", &(*newpoly)->width);
4222 }
4223 for (--keyptr; *keyptr == ' '; keyptr--);
4224 for (; *keyptr != ' '; keyptr--);
4225 /* check for "addtox" and "addtoy" parameter specification */
4226 while (!strncmp(keyptr + 1, "addto", 5)) {
4227 saveptr = keyptr + 1;
4228
4229 for (--keyptr; *keyptr == ' '; keyptr--);
4230 for (; *keyptr != ' '; keyptr--);
4231
4232 /* Get parameter and its value */
4233 if (*(saveptr + 5) == 'x')
4234 varpscan(localdata, keyptr + 1, &px, (genericptr)*newpoly,
4235 -1, offx, P_POSITION_X);
4236 else
4237 varpscan(localdata, keyptr + 1, &py, (genericptr)*newpoly,
4238 -1, offy, P_POSITION_Y);
4239
4240 for (--keyptr; *keyptr == ' '; keyptr--);
4241 for (; *keyptr != ' '; keyptr--);
4242 }
4243 sscanf(keyptr, "%hd", &(*newpoly)->number);
4244
4245 if (version >= 1.5) {
4246 lineptr = varscan(localdata, lineptr, &(*newpoly)->style,
4247 (genericptr)*newpoly, P_STYLE);
4248 lineptr = varfscan(localdata, lineptr, &(*newpoly)->width,
4249 (genericptr)*newpoly, P_LINEWIDTH);
4250 }
4251 }
4252
4253 if ((*newpoly)->style & BBOX)
4254 (*newpoly)->color = BBOXCOLOR;
4255 else
4256 (*newpoly)->color = curcolor;
4257 (*newpoly)->points = (pointlist) malloc((*newpoly)->number *
4258 sizeof(XPoint));
4259
4260 for (newpoints = (*newpoly)->points; newpoints < (*newpoly)->points
4261 + (*newpoly)->number; newpoints++) {
4262 lineptr = varpscan(localdata, lineptr, &newpoints->x,
4263 (genericptr)*newpoly, newpoints - (*newpoly)->points,
4264 offx + px, P_POSITION_X);
4265 lineptr = varpscan(localdata, lineptr, &newpoints->y,
4266 (genericptr)*newpoly, newpoints - (*newpoly)->points,
4267 offy + py, P_POSITION_Y);
4268 }
4269 std_eparam((genericptr)(*newpoly), colorkey);
4270 }
4271
4272 /* read spline curves */
4273
4274 else if (!strcmp(keyword, "spline")) {
4275 splineptr *newspline;
4276 px = py = 0;
4277
4278 NEW_SPLINE(newspline, localdata);
4279 (*newspline)->color = curcolor;
4280 (*newspline)->passed = NULL;
4281 (*newspline)->cycle = NULL;
4282
4283 /* backward compatibility */
4284 if (version < 1.5) {
4285 sscanf(buffer, "%f %hd %hd %hd %hd %hd %hd %hd %hd %hd",
4286 &(*newspline)->width, &(*newspline)->ctrl[1].x,
4287 &(*newspline)->ctrl[1].y, &(*newspline)->ctrl[2].x,
4288 &(*newspline)->ctrl[2].y, &(*newspline)->ctrl[3].x,
4289 &(*newspline)->ctrl[3].y, &(*newspline)->ctrl[0].x,
4290 &(*newspline)->ctrl[0].y, &(*newspline)->style);
4291 (*newspline)->ctrl[1].x -= offx; (*newspline)->ctrl[2].x -= offx;
4292 (*newspline)->ctrl[0].x -= offx;
4293 (*newspline)->ctrl[3].x -= offx;
4294 (*newspline)->ctrl[1].y -= offy; (*newspline)->ctrl[2].y -= offy;
4295 (*newspline)->ctrl[3].y -= offy;
4296 (*newspline)->ctrl[0].y -= offy;
4297 }
4298 else {
4299
4300 for (--keyptr; *keyptr == ' '; keyptr--);
4301 for (; *keyptr != ' '; keyptr--);
4302 /* check for "addtox" and "addtoy" parameter specification */
4303 while (!strncmp(keyptr + 1, "addto", 5)) {
4304 saveptr = keyptr + 1;
4305
4306 for (--keyptr; *keyptr == ' '; keyptr--);
4307 for (; *keyptr != ' '; keyptr--);
4308
4309 /* Get parameter and its value */
4310 if (*(saveptr + 5) == 'x')
4311 varpscan(localdata, keyptr + 1, &px, (genericptr)*newspline,
4312 -1, offx, P_POSITION_X);
4313 else
4314 varpscan(localdata, keyptr + 1, &py, (genericptr)*newspline,
4315 -1, offy, P_POSITION_Y);
4316
4317 for (--keyptr; *keyptr == ' '; keyptr--);
4318 for (; *keyptr != ' '; keyptr--);
4319 }
4320
4321 lineptr = varscan(localdata, buffer, &(*newspline)->style,
4322 (genericptr)*newspline, P_STYLE);
4323 lineptr = varfscan(localdata, lineptr, &(*newspline)->width,
4324 (genericptr)*newspline, P_LINEWIDTH);
4325 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[1].x,
4326 (genericptr)*newspline, 1, offx + px, P_POSITION_X);
4327 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[1].y,
4328 (genericptr)*newspline, 1, offy + py, P_POSITION_Y);
4329 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[2].x,
4330 (genericptr)*newspline, 2, offx + px, P_POSITION_X);
4331 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[2].y,
4332 (genericptr)*newspline, 2, offy + py, P_POSITION_Y);
4333 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[3].x,
4334 (genericptr)*newspline, 3, offx + px, P_POSITION_X);
4335 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[3].y,
4336 (genericptr)*newspline, 3, offy + py, P_POSITION_Y);
4337 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[0].x,
4338 (genericptr)*newspline, 0, offx + px, P_POSITION_X);
4339 lineptr = varpscan(localdata, lineptr, &(*newspline)->ctrl[0].y,
4340 (genericptr)*newspline, 0, offy + py, P_POSITION_Y);
4341
4342 /* check for "addtox" and "addtoy" parameter specification */
4343 }
4344
4345 calcspline(*newspline);
4346 std_eparam((genericptr)(*newspline), colorkey);
4347 }
4348
4349 /* read graphics image instances */
4350
4351 else if (!strcmp(keyword, "graphic")) {
4352 graphicptr *newgp;
4353 Imagedata *img;
4354
4355 lineptr = buffer + 1;
4356 for (i = 0; i < xobjs.images; i++) {
4357 img = xobjs.imagelist + i;
4358 if (!strncmp(img->filename, lineptr, strlen(img->filename))) {
4359 NEW_GRAPHIC(newgp, localdata);
4360 (*newgp)->color = curcolor;
4361 (*newgp)->passed = NULL;
4362 #ifndef HAVE_CAIRO
4363 (*newgp)->clipmask = (Pixmap)NULL;
4364 (*newgp)->target = NULL;
4365 (*newgp)->valid = False;
4366 #endif /* HAVE_CAIRO */
4367 (*newgp)->source = img->image;
4368 img->refcount++;
4369 lineptr += strlen(img->filename) + 1;
4370 break;
4371 }
4372 }
4373 if (i == xobjs.images) {
4374 /* Error: Line points to a non-existant image (no data) */
4375 /* See if we can load the image name as a filename, and */
4376 /* if that fails, then we must throw an error and ignore */
4377 /* the image element. */
4378
4379 graphicptr locgp;
4380 char *sptr = strchr(lineptr, ' ');
4381
4382 if (sptr != NULL)
4383 *sptr = '\0';
4384 else
4385 sptr = lineptr;
4386 locgp = new_graphic(NULL, lineptr, 0, 0);
4387
4388 if (locgp == NULL) {
4389 Fprintf(stderr, "Error: No graphic data for \"%s\".\n",
4390 lineptr);
4391 newgp = NULL;
4392 }
4393 else {
4394 lineptr = sptr;
4395 newgp = &locgp;
4396 }
4397 }
4398
4399 if ((newgp != NULL) && (*newgp != NULL)) {
4400 lineptr = varfscan(localdata, lineptr, &(*newgp)->scale,
4401 (genericptr)*newgp, P_SCALE);
4402 lineptr = varfscan(localdata, lineptr, &(*newgp)->rotation,
4403 (genericptr)*newgp, P_ROTATION);
4404 lineptr = varpscan(localdata, lineptr, &(*newgp)->position.x,
4405 (genericptr)*newgp, 0, offx, P_POSITION_X);
4406 lineptr = varpscan(localdata, lineptr, &(*newgp)->position.y,
4407 (genericptr)*newgp, 0, offy, P_POSITION_Y);
4408 std_eparam((genericptr)(*newgp), colorkey);
4409 }
4410 }
4411
4412 /* read labels */
4413
4414 else if (!strcmp(keyword, "fontset")) { /* old style */
4415 char tmpstring[100];
4416 int i;
4417 sscanf(buffer, "%f %*c%99s", &tmpscale, tmpstring);
4418 for (i = 0; i < fontcount; i++)
4419 if (!strcmp(tmpstring, fonts[i].psname)) {
4420 tmpfont = i;
4421 break;
4422 }
4423 if (i == fontcount) i = 0; /* Why bother with anything fancy? */
4424 }
4425
4426 else if (!strcmp(keyword, "label") || !strcmp(keyword, "pinlabel")
4427 || !strcmp(keyword, "pinglobal") || !strcmp(keyword, "infolabel")) {
4428
4429 labelptr *newlabel;
4430 stringpart *firstscale, *firstfont;
4431
4432 NEW_LABEL(newlabel, localdata);
4433 (*newlabel)->color = curcolor;
4434 (*newlabel)->string = NULL;
4435 (*newlabel)->passed = NULL;
4436 (*newlabel)->cycle = NULL;
4437
4438 /* scan backwards to get the number of substrings */
4439 lineptr = keyptr - 1;
4440 for (i = 0; i < ((version < 2.25) ? 5 : 6); i++) {
4441 for (; *lineptr == ' '; lineptr--);
4442 for (; *lineptr != ' '; lineptr--);
4443 }
4444 if ((strchr(lineptr, '.') != NULL) && (version < 2.25)) {
4445 Fprintf(stderr, "Error: File version claims to be %2.1f,"
4446 " but has version %2.1f labels\n", version, PROG_VERSION);
4447 Fprintf(stderr, "Attempting to resolve problem by updating version.\n");
4448 version = PROG_VERSION;
4449 for (; *lineptr == ' '; lineptr--);
4450 for (; *lineptr != ' '; lineptr--);
4451 }
4452 /* no. segments is ignored---may be a derived quantity, anyway */
4453 if (version < 2.25) {
4454 sscanf(lineptr, "%*s %hd %hf %hd %hd", &(*newlabel)->anchor,
4455 &(*newlabel)->rotation, &(*newlabel)->position.x,
4456 &(*newlabel)->position.y);
4457 (*newlabel)->position.x -= offx; (*newlabel)->position.y -= offy;
4458 *lineptr = '\0';
4459 }
4460 else {
4461 *lineptr++ = '\0';
4462 lineptr = advancetoken(lineptr); /* skip string token */
4463 lineptr = varscan(localdata, lineptr, &(*newlabel)->anchor,
4464 (genericptr)*newlabel, P_ANCHOR);
4465 lineptr = varfscan(localdata, lineptr, &(*newlabel)->rotation,
4466 (genericptr)*newlabel, P_ROTATION);
4467 lineptr = varfscan(localdata, lineptr, &(*newlabel)->scale,
4468 (genericptr)*newlabel, P_SCALE);
4469 lineptr = varpscan(localdata, lineptr, &(*newlabel)->position.x,
4470 (genericptr)*newlabel, 0, offx, P_POSITION_X);
4471 lineptr = varpscan(localdata, lineptr, &(*newlabel)->position.y,
4472 (genericptr)*newlabel, 0, offy, P_POSITION_Y);
4473 }
4474 if (version < 2.4)
4475 (*newlabel)->rotation = -(*newlabel)->rotation;
4476 while ((*newlabel)->rotation < 0.0) (*newlabel)->rotation += 360.0;
4477
4478 (*newlabel)->pin = False;
4479 if (strcmp(keyword, "label")) { /* all the schematic types */
4480 /* enable schematic capture if it is not already on. */
4481 if (!strcmp(keyword, "pinlabel"))
4482 (*newlabel)->pin = LOCAL;
4483 else if (!strcmp(keyword, "pinglobal"))
4484 (*newlabel)->pin = GLOBAL;
4485 else if (!strcmp(keyword, "infolabel")) {
4486 /* Do not turn top-level pages into symbols! */
4487 /* Info labels on schematics are treated differently. */
4488 if (localdata != topobject)
4489 localdata->schemtype = FUNDAMENTAL;
4490 (*newlabel)->pin = INFO;
4491 if (curcolor == DEFAULTCOLOR)
4492 (*newlabel)->color = INFOLABELCOLOR;
4493 }
4494 }
4495
4496 lineptr = buffer; /* back to beginning of string */
4497 if (!strncmp(lineptr, "mark", 4)) lineptr += 4;
4498
4499 readlabel(localdata, lineptr, &(*newlabel)->string);
4500 CheckMarginStop(*newlabel, areawin->topinstance, FALSE);
4501
4502 if (version < 2.25) {
4503 /* Switch 1st scale designator to overall font scale */
4504
4505 firstscale = (*newlabel)->string->nextpart;
4506 if (firstscale->type != FONT_SCALE) {
4507 if (tmpscale != 0.0)
4508 (*newlabel)->scale = 0.0;
4509 else
4510 (*newlabel)->scale = 1.0;
4511 }
4512 else {
4513 (*newlabel)->scale = firstscale->data.scale;
4514 deletestring(firstscale, &((*newlabel)->string),
4515 areawin->topinstance);
4516 }
4517 }
4518
4519 firstfont = (*newlabel)->string;
4520 if ((firstfont == NULL) || (firstfont->type != FONT_NAME)) {
4521 if (tmpfont == -1) {
4522 Fprintf(stderr, "Error: Label with no font designator?\n");
4523 tmpfont = 0;
4524 }
4525 firstfont = makesegment(&((*newlabel)->string), (*newlabel)->string);
4526 firstfont->type = FONT_NAME;
4527 firstfont->data.font = tmpfont;
4528 }
4529 cleanuplabel(&(*newlabel)->string);
4530
4531 std_eparam((genericptr)(*newlabel), colorkey);
4532 }
4533
4534 /* read symbol-to-schematic connection */
4535
4536 else if (!strcmp(keyword, "is_schematic")) {
4537 char tempstr[50];
4538 for (lineptr = buffer; *lineptr == ' '; lineptr++);
4539 parse_ps_string(++lineptr, tempstr, 49, FALSE, FALSE);
4540 checksym(localdata, tempstr);
4541 }
4542
4543 /* read bounding box (font files only) */
4544
4545 else if (!strcmp(keyword, "bbox")) {
4546 for (lineptr = buffer; *lineptr == ' '; lineptr++);
4547 if (*lineptr != '%') {
4548 Wprintf("Illegal bbox.");
4549 free(buffer);
4550 *retstr = '\0';
4551 return True;
4552 }
4553 sscanf(++lineptr, "%hd %hd %hd %hd",
4554 &localdata->bbox.lowerleft.x, &localdata->bbox.lowerleft.y,
4555 &localdata->bbox.width, &localdata->bbox.height);
4556
4557 // If this is *not* a FONTLIB, then the font character symbols
4558 // are being edited as a normal library, so copy the bounding
4559 // box into a FIXEDBBOX-type box.
4560
4561 if (mode != FONTLIB) {
4562 polyptr *newpoly;
4563 pointlist newpoints;
4564
4565 NEW_POLY(newpoly, localdata);
4566 (*newpoly)->passed = NULL;
4567 (*newpoly)->cycle = NULL;
4568 (*newpoly)->number = 4;
4569 (*newpoly)->width = 1.0;
4570 (*newpoly)->style = FIXEDBBOX;
4571 (*newpoly)->color = FIXEDBBOXCOLOR;
4572 (*newpoly)->points = (pointlist) malloc(4 * sizeof(XPoint));
4573 newpoints = (*newpoly)->points;
4574 newpoints->x = localdata->bbox.lowerleft.x;
4575 newpoints->y = localdata->bbox.lowerleft.y;
4576 newpoints++;
4577 newpoints->x = localdata->bbox.lowerleft.x + localdata->bbox.width;
4578 newpoints->y = localdata->bbox.lowerleft.y;
4579 newpoints++;
4580 newpoints->x = localdata->bbox.lowerleft.x + localdata->bbox.width;
4581 newpoints->y = localdata->bbox.lowerleft.y + localdata->bbox.height;
4582 newpoints++;
4583 newpoints->x = localdata->bbox.lowerleft.x;
4584 newpoints->y = localdata->bbox.lowerleft.y + localdata->bbox.height;
4585 std_eparam((genericptr)(*newpoly), colorkey);
4586 }
4587 }
4588
4589 /* read "hidden" attribute */
4590
4591 else if (!strcmp(keyword, "hidden")) {
4592 localdata->hidden = True;
4593 }
4594
4595 /* read "libinst" special instance of a library part */
4596
4597 else if (!strcmp(keyword, "libinst")) {
4598
4599 /* Read backwards from keyword to find name of object instanced. */
4600 for (lineptr = keyptr; *lineptr != '/' && lineptr > buffer;
4601 lineptr--);
4602 parse_ps_string(++lineptr, keyword, 79, FALSE, FALSE);
4603 new_library_instance(mode - LIBRARY, keyword, buffer, defaulttech);
4604 }
4605
4606 /* read objects */
4607
4608 else if (!strcmp(keyword, "{")) { /* This is an object definition */
4609 objlistptr redef;
4610 objectptr *newobject;
4611
4612 for (lineptr = buffer; *lineptr == ' '; lineptr++);
4613 if (*lineptr++ != '/') {
4614 /* This may be part of a label. . . treat as a continuation line */
4615 temp = continueline(&buffer);
4616 continue;
4617 }
4618 parse_ps_string(lineptr, keyword, 79, FALSE, FALSE);
4619
4620 newobject = new_library_object(mode, keyword, &redef, defaulttech);
4621
4622 if (objectread(ps, *newobject, 0, 0, mode, retstr, curcolor,
4623 defaulttech) == True) {
4624 strncpy(retstr, buffer, 150);
4625 retstr[149] = '\0';
4626 free(buffer);
4627 return True;
4628 }
4629 else {
4630 if (library_object_unique(mode, *newobject, redef))
4631 add_object_to_library(mode, *newobject);
4632 }
4633 }
4634 else if (!strcmp(keyword, "def")) {
4635 strncpy(retstr, buffer, 150);
4636 retstr[149] = '\0';
4637 free (buffer);
4638 return False; /* end of object def or end of object library */
4639 }
4640
4641 else if (!strcmp(keyword, "loadfontencoding")) {
4642 /* Deprecated, but retained for backward compatibility. */
4643 /* Load from script, .xcircuitrc, or command line instead. */
4644 for (lineptr = buffer; *lineptr != '%'; lineptr++);
4645 sscanf (lineptr + 1, "%149s", _STR);
4646 if (*(lineptr + 1) != '%') loadfontfile(_STR);
4647 }
4648 else if (!strcmp(keyword, "loadlibrary")) {
4649 /* Deprecated, but retained for backward compatibility */
4650 /* Load from script, .xcircuitrc, or command line instead. */
4651 int ilib, tlib;
4652
4653 for (lineptr = buffer; *lineptr != '%'; lineptr++);
4654 sscanf (++lineptr, "%149s", _STR);
4655 while (isspace(*lineptr)) lineptr++;
4656 while (!isspace(*++lineptr));
4657 while (isspace(*++lineptr));
4658 if (sscanf (lineptr, "%d", &ilib) > 0) {
4659 while ((ilib - 2 + LIBRARY) > xobjs.numlibs) {
4660 tlib = createlibrary(False);
4661 if (tlib != xobjs.numlibs - 2 + LIBRARY) {
4662 ilib = tlib;
4663 break;
4664 }
4665 }
4666 mode = ilib - 1 + LIBRARY;
4667 }
4668 loadlibrary(mode);
4669 }
4670 else if (!strcmp(keyword, "beginparm")) { /* parameterized object */
4671 short tmpnum, i;
4672 for (--keyptr; *keyptr == ' '; keyptr--);
4673 for (; isdigit(*keyptr) && (keyptr >= buffer); keyptr--);
4674 sscanf(keyptr, "%hd", &tmpnum);
4675 lineptr = buffer;
4676 while (isspace(*lineptr)) lineptr++;
4677
4678 if (tmpnum < 256) { /* read parameter defaults in order */
4679 stringpart *newpart;
4680 /* oparamptr newops; (jdk) */
4681
4682 for (i = 0; i < tmpnum; i++) {
4683 oparamptr newops;
4684
4685 newops = (oparamptr)malloc(sizeof(oparam));
4686 newops->next = localdata->params;
4687 localdata->params = newops;
4688 newops->key = (char *)malloc(6);
4689 sprintf(newops->key, "v%d", i + 1);
4690
4691 if (*lineptr == '(' || *lineptr == '{') { /* type is XC_STRING */
4692 char *linetmp, csave;
4693
4694 newops->parameter.string = NULL;
4695
4696 /* get simple substring or set of substrings and commands */
4697 linetmp = find_delimiter(lineptr);
4698 csave = *(++linetmp);
4699 *linetmp = '\0';
4700 if (*lineptr == '{') lineptr++;
4701 readlabel(localdata, lineptr, &(newops->parameter.string));
4702
4703 /* Add the ending part to the parameter string */
4704 newpart = makesegment(&(newops->parameter.string), NULL);
4705 newpart->type = PARAM_END;
4706 newpart->data.string = (u_char *)NULL;
4707
4708 newops->type = (u_char)XC_STRING;
4709 newops->which = P_SUBSTRING;
4710 /* Fprintf(stdout, "Parameter %d to object %s defaults "
4711 "to string \"%s\"\n", i + 1, localdata->name,
4712 ops->parameter.string); */
4713 *linetmp = csave;
4714 lineptr = linetmp;
4715 while (isspace(*lineptr)) lineptr++;
4716 }
4717 else { /* type is assumed to be XC_FLOAT */
4718 newops->type = (u_char)XC_FLOAT;
4719 sscanf(lineptr, "%g", &newops->parameter.fvalue);
4720 /* Fprintf(stdout, "Parameter %s to object %s defaults to "
4721 "value %g\n", newops->key, localdata->name,
4722 newops->parameter.fvalue); */
4723 lineptr = advancetoken(lineptr);
4724 }
4725 }
4726 }
4727 }
4728 else if (!strcmp(keyword, "nonetwork")) {
4729 localdata->valid = True;
4730 localdata->schemtype = NONETWORK;
4731 }
4732 else if (!strcmp(keyword, "trivial")) {
4733 localdata->schemtype = TRIVIAL;
4734 }
4735 else if (!strcmp(keyword, "begingate")) {
4736 localdata->params = NULL;
4737 /* read dictionary of parameter key:value pairs */
4738 readparams(NULL, NULL, localdata, buffer);
4739 }
4740
4741 else if (!strcmp(keyword, "%%Trailer")) break;
4742 else if (!strcmp(keyword, "EndLib")) break;
4743 else if (!strcmp(keyword, "restore")); /* handled at top */
4744 else if (!strcmp(keyword, "grestore")); /* ignore */
4745 else if (!strcmp(keyword, "endgate")); /* also ignore */
4746 else if (!strcmp(keyword, "xyarray")); /* ignore for now */
4747 else {
4748 char *tmpptr, *libobjname, *objnamestart;
4749 Boolean matchtech, found = False;
4750
4751 /* First, make sure this is not a general comment line */
4752 /* Return if we have a page boundary */
4753 /* Read an image if this is an imagedata line. */
4754
4755 for (tmpptr = buffer; isspace(*tmpptr); tmpptr++);
4756 if (*tmpptr == '%') {
4757 if (strstr(buffer, "%%Page:") == tmpptr) {
4758 strncpy(retstr, buffer, 150);
4759 retstr[149] = '\0';
4760 free (buffer);
4761 return True;
4762 }
4763 else if (strstr(buffer, "%imagedata") == tmpptr) {
4764 int width, height;
4765 sscanf(buffer, "%*s %d %d", &width, &height);
4766 readimagedata(ps, width, height);
4767 }
4768 continue;
4769 }
4770
4771 parse_ps_string(keyword, keyword, 79, FALSE, FALSE);
4772 matchtech = (strstr(keyword, "::") == NULL) ? FALSE : TRUE;
4773
4774 /* If the file contains a reference to a bare-word device */
4775 /* without a technology prefix, then it is probably an */
4776 /* older-version file. If this is the case, then the file */
4777 /* should define an unprefixed object, which will be given */
4778 /* a null prefix (just "::" by itself). Look for that */
4779 /* match. */
4780
4781 /* (Assume that this line calls an object instance) */
4782 /* Double loop through user libraries */
4783
4784 for (k = 0; k < ((mode == FONTLIB) ? 1 : xobjs.numlibs); k++) {
4785 for (j = 0; j < ((mode == FONTLIB) ? xobjs.fontlib.number :
4786 xobjs.userlibs[k].number); j++) {
4787
4788 libobj = (mode == FONTLIB) ? xobjs.fontlib.library + j :
4789 xobjs.userlibs[k].library + j;
4790
4791 /* Objects which have a technology ("<lib>::<obj>") */
4792 /* must compare exactly. Objects which don't can */
4793 /* only match an object of the same name with a null */
4794 /* technology prefix. */
4795
4796 libobjname = (*libobj)->name;
4797 if (!matchtech) {
4798 objnamestart = strstr(libobjname, "::");
4799 if (objnamestart != NULL) libobjname = objnamestart + 2;
4800 }
4801 if (!objnamecmp(keyword, libobjname)) {
4802
4803 /* If the name is not exactly the same (appended underscores) */
4804 /* check if the name is on the list of aliases. */
4805
4806 if (strcmp(keyword, libobjname)) {
4807 Boolean is_alias = False;
4808 aliasptr ckalias = aliastop;
4809 slistptr sref;
4810
4811 for (; ckalias != NULL; ckalias = ckalias->next) {
4812 if (ckalias->baseobj == (*libobj)) {
4813 sref = ckalias->aliases;
4814 for (; sref != NULL; sref = sref->next) {
4815 if (!strcmp(keyword, sref->alias)) {
4816 is_alias = True;
4817 break;
4818 }
4819 }
4820 if (is_alias) break;
4821 }
4822 }
4823 if (!is_alias) continue;
4824 }
4825
4826 if (!matchtech && ((*libobj)->name != objnamestart))
4827 if (version > 3.7)
4828 continue; // no prefix in file must match
4829 // null prefix in library object.
4830
4831 found = True;
4832 NEW_OBJINST(newinst, localdata);
4833 (*newinst)->thisobject = *libobj;
4834 (*newinst)->color = curcolor;
4835 (*newinst)->params = NULL;
4836 (*newinst)->passed = NULL;
4837 (*newinst)->bbox.lowerleft.x = (*libobj)->bbox.lowerleft.x;
4838 (*newinst)->bbox.lowerleft.y = (*libobj)->bbox.lowerleft.y;
4839 (*newinst)->bbox.width = (*libobj)->bbox.width;
4840 (*newinst)->bbox.height = (*libobj)->bbox.height;
4841 (*newinst)->schembbox = NULL;
4842
4843 lineptr = varfscan(localdata, buffer, &(*newinst)->scale,
4844 (genericptr)*newinst, P_SCALE);
4845
4846 /* Format prior to xcircuit 3.7 did not have scale- */
4847 /* invariant linewidth. If scale is 1, though, keep it */
4848 /* invariant so as not to overuse the scale-variance */
4849 /* flag in the output file. */
4850
4851 if ((version < 3.7) && ((*newinst)->scale != 1.0))
4852 (*newinst)->style = NORMAL;
4853 else
4854 (*newinst)->style = LINE_INVARIANT;
4855
4856 lineptr = varfscan(localdata, lineptr, &(*newinst)->rotation,
4857 (genericptr)*newinst, P_ROTATION);
4858 lineptr = varpscan(localdata, lineptr, &(*newinst)->position.x,
4859 (genericptr)*newinst, 0, offx, P_POSITION_X);
4860 lineptr = varpscan(localdata, lineptr, &(*newinst)->position.y,
4861 (genericptr)*newinst, 0, offy, P_POSITION_Y);
4862
4863 /* Negative rotations = flip in x in version 2.3.6 and */
4864 /* earlier. Later versions don't allow negative rotation */
4865
4866 if (version < 2.4) {
4867 if ((*newinst)->rotation < 0.0) {
4868 (*newinst)->scale = -((*newinst)->scale);
4869 (*newinst)->rotation += 1.0;
4870 }
4871 (*newinst)->rotation = -(*newinst)->rotation;
4872 }
4873
4874 while ((*newinst)->rotation > 360.0)
4875 (*newinst)->rotation -= 360.0;
4876 while ((*newinst)->rotation < 0.0)
4877 (*newinst)->rotation += 360.0;
4878
4879 std_eparam((genericptr)(*newinst), colorkey);
4880
4881 /* Does this instance contain parameters? */
4882 readparams(localdata, *newinst, *libobj, buffer);
4883
4884 calcbboxinst(*newinst);
4885
4886 break;
4887
4888 } /* if !strcmp */
4889 } /* for j loop */
4890 if (found) break;
4891 } /* for k loop */
4892 if (!found) /* will assume that we have a continuation line */
4893 temp = continueline(&buffer);
4894 }
4895 }
4896 }
4897 strncpy(retstr, buffer, 150);
4898 retstr[149] = '\0';
4899 free(buffer);
4900 return True;
4901 }
4902
4903 /*------------------------*/
4904 /* Save a PostScript file */
4905 /*------------------------*/
4906
4907 #ifdef TCL_WRAPPER
4908
4909 void setfile(char *filename, int mode)
4910 {
4911 if ((filename == NULL) || (xobjs.pagelist[areawin->page]->filename == NULL)) {
4912 Wprintf("Error: No filename for schematic.");
4913 if (beeper) XBell(dpy, 100);
4914 return;
4915 }
4916
4917 /* see if name has been changed in the buffer */
4918
4919 if (strcmp(xobjs.pagelist[areawin->page]->filename, filename)) {
4920 Wprintf("Changing name of edit file.");
4921 free(xobjs.pagelist[areawin->page]->filename);
4922 xobjs.pagelist[areawin->page]->filename = strdup(filename);
4923 }
4924
4925 if (strstr(xobjs.pagelist[areawin->page]->filename, "Page ") != NULL) {
4926 Wprintf("Warning: Enter a new name.");
4927 if (beeper) XBell(dpy, 100);
4928 }
4929 else {
4930 savefile(mode);
4931 if (beeper) XBell(dpy, 100);
4932 }
4933 }
4934
4935 #else /* !TCL_WRAPPER */
4936
4937 void setfile(xcWidget button, xcWidget fnamewidget, caddr_t clientdata)
4938 {
4939 /* see if name has been changed in the buffer */
4940
4941 sprintf(_STR2, "%.249s", (char *)XwTextCopyBuffer(fnamewidget));
4942 if (xobjs.pagelist[areawin->page]->filename == NULL) {
4943 xobjs.pagelist[areawin->page]->filename = strdup(_STR2);
4944 }
4945 else if (strcmp(xobjs.pagelist[areawin->page]->filename, _STR2)) {
4946 Wprintf("Changing name of edit file.");
4947 free(xobjs.pagelist[areawin->page]->filename);
4948 xobjs.pagelist[areawin->page]->filename = strdup(_STR2);
4949 }
4950 if (strstr(xobjs.pagelist[areawin->page]->filename, "Page ") != NULL) {
4951 Wprintf("Warning: Enter a new name.");
4952 if (beeper) XBell(dpy, 100);
4953 }
4954 else {
4955
4956 Arg wargs[1];
4957 xcWidget db, di;
4958
4959 savefile(CURRENT_PAGE);
4960
4961 /* Change "close" button to read "done" */
4962
4963 di = xcParent(button);
4964 db = XtNameToWidget(di, "Close");
4965 XtSetArg(wargs[0], XtNlabel, " Done ");
4966 XtSetValues(db, wargs, 1);
4967 if (beeper) XBell(dpy, 100);
4968 }
4969 }
4970
4971 #endif /* TCL_WRAPPER */
4972
4973 /*--------------------------------------------------------------*/
4974 /* Update number of changes for an object and initiate a temp */
4975 /* file save if total number of unsaved changes exceeds 20. */
4976 /*--------------------------------------------------------------*/
4977
4978 void incr_changes(objectptr thisobj)
4979 {
4980 /* It is assumed that empty pages are meant to be that way */
4981 /* and are not to be saved, so changes are marked as zero. */
4982
4983 if (thisobj->parts == 0) {
4984 thisobj->changes = 0;
4985 return;
4986 }
4987
4988 /* Remove any pending timeout */
4989
4990 if (xobjs.timeout_id != (xcIntervalId)NULL) {
4991 xcRemoveTimeOut(xobjs.timeout_id);
4992 xobjs.timeout_id = (xcIntervalId)NULL;
4993 }
4994
4995 thisobj->changes++;
4996
4997 /* When in "suspend" mode, we assume that we are reading commands from
4998 * a script, and therefore we should not continuously increment changes
4999 * and keep saving the backup file.
5000 */
5001
5002 if (xobjs.suspend < 0)
5003 xobjs.new_changes++;
5004
5005 if (xobjs.new_changes > MAXCHANGES) {
5006 #ifdef TCL_WRAPPER
5007 savetemp(NULL);
5008 #else
5009 savetemp(NULL, NULL);
5010 #endif
5011 }
5012
5013 /* Generate a new timeout */
5014
5015 xobjs.timeout_id = xcAddTimeOut(app, 60000 * xobjs.save_interval,
5016 savetemp, NULL);
5017 }
5018
5019 /*--------------------------------------------------------------*/
5020 /* tempfile save */
5021 /*--------------------------------------------------------------*/
5022
5023 #ifdef TCL_WRAPPER
5024
5025 void savetemp(ClientData clientdata)
5026 {
5027
5028 #else
5029
5030 void savetemp(XtPointer clientdata, xcIntervalId *id)
5031 {
5032
5033 #endif
5034
5035 /* Remove the timeout ID. If this routine is called from */
5036 /* incr_changes() instead of from the timeout interrupt */
5037 /* service routine, then this value will already be NULL. */
5038
5039 xobjs.timeout_id = (xcIntervalId)NULL;
5040
5041 /* First see if there are any unsaved changes in the file. */
5042 /* If not, then just reset the counter and continue. */
5043
5044 if (xobjs.new_changes > 0) {
5045 if (xobjs.tempfile == NULL)
5046 {
5047 int fd;
5048 char *template = (char *)malloc(20 + strlen(xobjs.tempdir));
5049 int pid = (int)getpid();
5050
5051 sprintf(template, "%s/XC%d.XXXXXX", xobjs.tempdir, pid);
5052
5053 #ifdef _MSC_VER
5054 fd = mktemp(template);
5055 #else
5056 fd = mkstemp(template);
5057 #endif
5058 if (fd == -1) {
5059 Fprintf(stderr, "Error generating file for savetemp\n");
5060 free(template);
5061 }
5062 close(fd);
5063 xobjs.tempfile = strdup(template);
5064 free(template);
5065 }
5066 /* Show the "wristwatch" cursor, as graphic data may cause this */
5067 /* step to be inordinately long. */
5068
5069 XDefineCursor(dpy, areawin->window, WAITFOR);
5070 savefile(ALL_PAGES);
5071 XDefineCursor(dpy, areawin->window, DEFAULTCURSOR);
5072 xobjs.new_changes = 0; /* reset the count */
5073 }
5074 }
5075
5076 /*----------------------------------------------------------------------*/
5077 /* Set all objects in the list "wroteobjs" as having no unsaved changes */
5078 /*----------------------------------------------------------------------*/
5079
5080 void setassaved(objectptr *wroteobjs, short written)
5081 {
5082 int i;
5083
5084 for (i = 0; i < written; i++)
5085 (*(wroteobjs + i))->changes = 0;
5086 }
5087
5088 /*---------------------------------------------------------------*/
5089 /* Save indicated library. If libno is 0, save current page if */
5090 /* the current page is a library. If not, save the user library */
5091 /*---------------------------------------------------------------*/
5092
5093 void savelibpopup(xcWidget button, char *technology, caddr_t nulldata)
5094 {
5095 TechPtr nsptr;
5096
5097 #ifndef TCL_WRAPPER
5098 buttonsave *savebutton;
5099 #endif
5100
5101 nsptr = LookupTechnology(technology);
5102
5103 if (nsptr != NULL) {
5104 if ((nsptr->flags & TECH_READONLY) != 0) {
5105 Wprintf("Library technology \"%s\" is read-only.", technology);
5106 return;
5107 }
5108 }
5109
5110 #ifndef TCL_WRAPPER
5111 savebutton = getgeneric(button, savelibpopup, technology);
5112 popupprompt(button, "Enter technology:", "\0", savelibrary,
5113 savebutton, NULL);
5114 #endif
5115 }
5116
5117 /*---------------------------------------------------------*/
5118
5119 #ifndef TCL_WRAPPER
5120
5121 void savelibrary(xcWidget w, char *technology)
5122 {
5123 char outname[250];
5124 sscanf(_STR2, "%249s", outname);
5125 savetechnology(technology, outname);
5126 }
5127
5128 #endif
5129
5130 /*---------------------------------------------------------*/
5131
5132 void savetechnology(char *technology, char *outname)
5133 {
5134 FILE *ps;
5135 char *outptr, *validname, outfile[150];
5136 objectptr *wroteobjs, libobjptr, *optr, depobj;
5137 genericptr *gptr;
5138 liblistptr spec;
5139 short written;
5140 short *glist;
5141 char *uname = NULL;
5142 char *hostname = NULL;
5143 struct passwd *mypwentry = NULL;
5144 int i, j, ilib;
5145 TechPtr nsptr;
5146 char *loctechnology;
5147
5148 // Don't use the string "(user)" as a technology name; this is just
5149 // a GUI placeholder for a null string (""). This shouldn't happen,
5150 // though, as technology should be NULL if the user technology is
5151 // selected.
5152
5153 if (technology && (!strcmp(technology, "(user)")))
5154 nsptr = LookupTechnology(NULL);
5155 else
5156 nsptr = LookupTechnology(technology);
5157
5158 if ((outptr = strrchr(outname, '/')) == NULL)
5159 outptr = outname;
5160 else
5161 outptr++;
5162 strcpy(outfile, outname);
5163 if (strchr(outptr, '.') == NULL) strcat(outfile, ".lps");
5164
5165 xc_tilde_expand(outfile, 149);
5166 while(xc_variable_expand(outfile, 149));
5167
5168 if (nsptr != NULL && nsptr->filename != NULL) {
5169 // To be pedantic, we should probably check that the inodes of the
5170 // files are different, to be sure we are avoiding an unintentional
5171 // over-write.
5172
5173 if (!strcmp(outfile, nsptr->filename)) {
5174
5175 if ((nsptr->flags & TECH_READONLY) != 0) {
5176 Wprintf("Technology file \"%s\" is read-only.", technology);
5177 return;
5178 }
5179
5180 if ((nsptr->flags & TECH_IMPORTED) != 0) {
5181 Wprintf("Attempt to write a truncated technology file!");
5182 return;
5183 }
5184 }
5185 }
5186
5187 ps = fopen(outfile, "wb");
5188 if (ps == NULL) {
5189 Wprintf("Can't open PS file.");
5190 if (nsptr && nsptr->filename && (!strcmp(nsptr->filename, outfile))) {
5191 Wprintf("Marking technology \"%s\" as read-only.", technology);
5192 nsptr->flags |= TECH_READONLY;
5193 }
5194 return;
5195 }
5196
5197 /* Did the technology name change? If so, register the new name. */
5198 /* Clear any "IMPORTED" or "READONLY" flags. */
5199
5200 if (nsptr && nsptr->filename && strcmp(outfile, nsptr->filename)) {
5201 Wprintf("Technology filename changed from \"%s\" to \"%s\".",
5202 nsptr->filename, outfile);
5203 free(nsptr->filename);
5204 nsptr->filename = strdup(outfile);
5205 nsptr->flags &= ~(TECH_READONLY | TECH_IMPORTED);
5206 }
5207 else if (nsptr && !nsptr->filename) {
5208 nsptr->filename = strdup(outfile);
5209 nsptr->flags &= ~(TECH_READONLY | TECH_IMPORTED);
5210 }
5211
5212 fprintf(ps, "%%! PostScript set of library objects for XCircuit\n");
5213 fprintf(ps, "%% Version: %2.1f\n", version);
5214 fprintf(ps, "%% Library name is: %s\n",
5215 (technology == NULL) ? "(user)" : technology);
5216 #ifdef _MSC_VER
5217 uname = getenv((const char *)"USERNAME");
5218 #else
5219 uname = getenv((const char *)"USER");
5220 if (uname != NULL) mypwentry = getpwnam(uname);
5221 #endif
5222
5223 /* Check for both $HOST and $HOSTNAME environment variables. Thanks */
5224 /* to frankie liu <frankliu@Stanford.EDU> for this fix. */
5225
5226 if ((hostname = getenv((const char *)"HOSTNAME")) == NULL)
5227 if ((hostname = getenv((const char *)"HOST")) == NULL) {
5228 if (gethostname(_STR, 149) != 0)
5229 hostname = uname;
5230 else
5231 hostname = _STR;
5232 }
5233
5234 #ifndef _MSC_VER
5235 if (mypwentry != NULL)
5236 fprintf(ps, "%% Author: %s <%s@%s>\n", mypwentry->pw_gecos, uname,
5237 hostname);
5238 #endif
5239
5240 fprintf(ps, "%%\n\n");
5241
5242 /* Print lists of object dependencies, where they exist. */
5243 /* Note that objects can depend on objects in other technologies; */
5244 /* this is allowed. */
5245
5246 wroteobjs = (objectptr *) malloc(sizeof(objectptr));
5247 for (ilib = 0; ilib < xobjs.numlibs; ilib++) {
5248 for (j = 0; j < xobjs.userlibs[ilib].number; j++) {
5249
5250 libobjptr = *(xobjs.userlibs[ilib].library + j);
5251 if (CompareTechnology(libobjptr, technology)) {
5252 written = 0;
5253
5254 /* Search for all object definitions instantiated in this object, */
5255 /* and add them to the dependency list (non-recursive). */
5256
5257 for (gptr = libobjptr->plist; gptr < libobjptr->plist
5258 + libobjptr->parts; gptr++) {
5259 if (IS_OBJINST(*gptr)) {
5260 depobj = TOOBJINST(gptr)->thisobject;
5261
5262 /* Search among the list of objects already collected. */
5263 /* If this object has been previously, then ignore it. */
5264 /* Otherwise, update the list of object dependencies */
5265
5266 for (optr = wroteobjs; optr < wroteobjs + written; optr++)
5267 if (*optr == depobj)
5268 break;
5269
5270 if (optr == wroteobjs + written) {
5271 wroteobjs = (objectptr *)realloc(wroteobjs, (written + 1) *
5272 sizeof(objectptr));
5273 *(wroteobjs + written) = depobj;
5274 written++;
5275 }
5276 }
5277 }
5278 if (written > 0) {
5279 fprintf(ps, "%% Depend %s", libobjptr->name);
5280 for (i = 0; i < written; i++) {
5281 depobj = *(wroteobjs + i);
5282 fprintf(ps, " %s", depobj->name);
5283 }
5284 fprintf(ps, "\n");
5285 }
5286 }
5287 }
5288 }
5289
5290 fprintf(ps, "\n%% XCircuitLib library objects\n");
5291
5292 /* Start by looking for any graphic images in the library objects */
5293 /* and saving the graphic image data at the top of the file. */
5294
5295 glist = (short *)malloc(xobjs.images * sizeof(short));
5296 for (i = 0; i < xobjs.images; i++) glist[i] = 0;
5297
5298 for (ilib = 0; ilib < xobjs.numlibs; ilib++) {
5299 for (spec = xobjs.userlibs[ilib].instlist; spec != NULL; spec = spec->next) {
5300 libobjptr = spec->thisinst->thisobject;
5301 if (CompareTechnology(libobjptr, technology))
5302 count_graphics(spec->thisinst->thisobject, glist);
5303 }
5304 }
5305 output_graphic_data(ps, glist);
5306 free(glist);
5307
5308 /* list of library objects already written */
5309
5310 wroteobjs = (objectptr *)realloc(wroteobjs, sizeof(objectptr));
5311 written = 0;
5312
5313 /* write all of the object definitions used, bottom up, with virtual */
5314 /* instances in the correct placement. The need to find virtual */
5315 /* instances is why we do a look through the library pages and not */
5316 /* the libraries themselves when looking for objects matching the */
5317 /* given technology. */
5318
5319 for (ilib = 0; ilib < xobjs.numlibs; ilib++) {
5320 for (spec = xobjs.userlibs[ilib].instlist; spec != NULL; spec = spec->next) {
5321 libobjptr = spec->thisinst->thisobject;
5322 if (CompareTechnology(libobjptr, technology)) {
5323 if (!spec->virtual) {
5324 printobjects(ps, spec->thisinst->thisobject, &wroteobjs,
5325 &written, DEFAULTCOLOR);
5326 }
5327 else {
5328 if ((spec->thisinst->scale != 1.0) ||
5329 (spec->thisinst->rotation != 0.0)) {
5330 fprintf(ps, "%3.3f %3.3f ", spec->thisinst->scale,
5331 spec->thisinst->rotation);
5332 }
5333 printparams(ps, spec->thisinst, 0);
5334 validname = create_valid_psname(spec->thisinst->thisobject->name, FALSE);
5335 /* Names without technologies get '::' string (blank technology) */
5336 if (technology == NULL)
5337 fprintf(ps, "/::%s libinst\n", validname);
5338 else
5339 fprintf(ps, "/%s libinst\n", validname);
5340 if ((spec->next != NULL) && (!(spec->next->virtual)))
5341 fprintf(ps, "\n");
5342 }
5343 }
5344 }
5345 }
5346
5347 setassaved(wroteobjs, written);
5348 if (nsptr) nsptr->flags &= (~TECH_CHANGED);
5349 xobjs.new_changes = countchanges(NULL);
5350
5351 /* and the postlog */
5352
5353 fprintf(ps, "\n%% EndLib\n");
5354 fclose(ps);
5355 if (technology != NULL)
5356 Wprintf("Library technology \"%s\" saved as file %s.",technology, outname);
5357 else
5358 Wprintf("Library technology saved as file %s.", outname);
5359
5360 free(wroteobjs);
5361 }
5362
5363 /*----------------------------------------------------------------------*/
5364 /* Recursive routine to search the object hierarchy for fonts used */
5365 /*----------------------------------------------------------------------*/
5366
5367 void findfonts(objectptr writepage, short *fontsused) {
5368 genericptr *dfp;
5369 stringpart *chp;
5370 int findex;
5371
5372 for (dfp = writepage->plist; dfp < writepage->plist + writepage->parts; dfp++) {
5373 if (IS_LABEL(*dfp)) {
5374 for (chp = TOLABEL(dfp)->string; chp != NULL; chp = chp->nextpart) {
5375 if (chp->type == FONT_NAME) {
5376 findex = chp->data.font;
5377 if (fontsused[findex] == 0) {
5378 fontsused[findex] = 0x8000 | fonts[findex].flags;
5379 }
5380 }
5381 }
5382 }
5383 else if (IS_OBJINST(*dfp)) {
5384 findfonts(TOOBJINST(dfp)->thisobject, fontsused);
5385 }
5386 }
5387 }
5388
5389 /*------------------------------------------------------*/
5390 /* Write graphics image data to file "ps". "glist" is */
5391 /* a pointer to a vector of short integers, each one */
5392 /* being an index into xobjs.images for an image that */
5393 /* is to be output. */
5394 /*------------------------------------------------------*/
5395
5396 void output_graphic_data(FILE *ps, short *glist)
5397 {
5398 char *fptr, ascbuf[6];
5399 int i, j;
5400 for (i = 0; i < xobjs.images; i++) {
5401 Imagedata *img = xobjs.imagelist + i;
5402 int ilen, flen, k, m = 0, n, q = 0;
5403 u_char *filtbuf, *flatebuf;
5404 Boolean lastpix = False;
5405 union {
5406 u_long i;
5407 u_char b[4];
5408 } pixel;
5409 int width = xcImageGetWidth(img->image);
5410 int height = xcImageGetHeight(img->image);
5411
5412 if (glist[i] == 0) continue;
5413
5414 fprintf(ps, "%%imagedata %d %d\n", width, height);
5415 fprintf(ps, "currentfile /ASCII85Decode filter ");
5416
5417 #ifdef HAVE_LIBZ
5418 fprintf(ps, "/FlateDecode filter\n");
5419 #endif
5420
5421 fprintf(ps, "/ReusableStreamDecode filter\n");
5422
5423 /* creating a stream buffer is wasteful if we're just using ASCII85 */
5424 /* decoding but is a must for compression filters. */
5425
5426 ilen = 3 * width * height;
5427 filtbuf = (u_char *)malloc(ilen + 4);
5428 q = 0;
5429
5430 for (j = 0; j < height; j++)
5431 for (k = 0; k < width; k++) {
5432 unsigned char r, g, b;
5433 xcImageGetPixel(img->image, k, j, &r, &g, &b);
5434 filtbuf[q++] = r;
5435 filtbuf[q++] = g;
5436 filtbuf[q++] = b;
5437 }
5438
5439 /* Extra encoding goes here */
5440 #ifdef HAVE_LIBZ
5441 flen = ilen * 2;
5442 flatebuf = (char *)malloc(flen);
5443 ilen = large_deflate(flatebuf, flen, filtbuf, ilen);
5444 free(filtbuf);
5445 #else
5446 flatebuf = filtbuf;
5447 #endif
5448
5449 ascbuf[5] = '\0';
5450 pixel.i = 0;
5451 for (j = 0; j < ilen; j += 4) {
5452 if ((j + 4) > ilen) lastpix = TRUE;
5453 if (!lastpix && (flatebuf[j] + flatebuf[j + 1] + flatebuf[j + 2]
5454 + flatebuf[j + 3] == 0)) {
5455 fprintf(ps, "z");
5456 m++;
5457 }
5458 else {
5459 for (n = 0; n < 4; n++)
5460 pixel.b[3 - n] = flatebuf[j + n];
5461
5462 ascbuf[0] = '!' + (pixel.i / 52200625);
5463 pixel.i %= 52200625;
5464 ascbuf[1] = '!' + (pixel.i / 614125);
5465 pixel.i %= 614125;
5466 ascbuf[2] = '!' + (pixel.i / 7225);
5467 pixel.i %= 7225;
5468 ascbuf[3] = '!' + (pixel.i / 85);
5469 pixel.i %= 85;
5470 ascbuf[4] = '!' + pixel.i;
5471 if (lastpix)
5472 for (n = 0; n < ilen + 1 - j; n++)
5473 fprintf(ps, "%c", ascbuf[n]);
5474 else
5475 fprintf(ps, "%5s", ascbuf);
5476 m += 5;
5477 }
5478 if (m > 75) {
5479 fprintf(ps, "\n");
5480 m = 0;
5481 }
5482 }
5483 fprintf(ps, "~>\n");
5484 free(flatebuf);
5485
5486 /* Remove any filesystem path information from the image name. */
5487 /* Otherwise, the slashes will cause PostScript to err. */
5488
5489 fptr = strrchr(img->filename, '/');
5490 if (fptr == NULL)
5491 fptr = img->filename;
5492 else
5493 fptr++;
5494 fprintf(ps, "/%sdata exch def\n", fptr);
5495 fprintf(ps, "/%s <<\n", fptr);
5496 fprintf(ps, " /ImageType 1 /Width %d /Height %d /BitsPerComponent 8\n",
5497 width, height);
5498 fprintf(ps, " /MultipleDataSources false\n");
5499 fprintf(ps, " /Decode [0 1 0 1 0 1]\n");
5500 fprintf(ps, " /ImageMatrix [1 0 0 -1 %d %d]\n",
5501 width >> 1, height >> 1);
5502 fprintf(ps, " /DataSource %sdata >> def\n\n", fptr);
5503 }
5504 }
5505
5506 /*----------------------------------------------------------------------*/
5507 /* Main file saving routine */
5508 /*----------------------------------------------------------------------*/
5509 /* mode description */
5510 /*----------------------------------------------------------------------*/
5511 /* ALL_PAGES saves a crash recovery backup file */
5512 /* CURRENT_PAGE saves all pages associated with the same */
5513 /* filename as the current page, and all */
5514 /* dependent schematics (which have their */
5515 /* filenames changed to match). */
5516 /* NO_SUBCIRCUITS saves all pages associated with the same */
5517 /* filename as the current page, only. */
5518 /*----------------------------------------------------------------------*/
5519
5520 void savefile(short mode)
5521 {
5522 FILE *ps, *pro, *enc;
5523 char outname[150], temp[150], prologue[150], *fname, *fptr, ascbuf[6];
5524 /* u_char decodebuf[6]; (jdk */
5525 short written, fontsused[256], i, page, curpage, multipage;
5526 short savepage, stcount, *pagelist, *glist;
5527 objectptr *wroteobjs;
5528 objinstptr writepage;
5529 int findex, j;
5530 time_t tdate;
5531 char *tmp_s;
5532
5533 if (mode != ALL_PAGES) {
5534 /* doubly-protected file write: protect against errors during file write */
5535 fname = xobjs.pagelist[areawin->page]->filename;
5536 sprintf(outname, "%s~", fname);
5537 rename(fname, outname);
5538 }
5539 else {
5540 /* doubly-protected backup: protect against errors during file write */
5541 sprintf(outname, "%sB", xobjs.tempfile);
5542 rename(xobjs.tempfile, outname);
5543 fname = xobjs.tempfile;
5544 }
5545
5546 if ((fptr = strrchr(fname, '/')) != NULL)
5547 fptr++;
5548 else
5549 fptr = fname;
5550
5551 if ((mode != ALL_PAGES) && (strchr(fptr, '.') == NULL))
5552 sprintf(outname, "%s.ps", fname);
5553 else sprintf(outname, "%s", fname);
5554
5555 xc_tilde_expand(outname, 149);
5556 while(xc_variable_expand(outname, 149));
5557
5558 ps = fopen(outname, "wb");
5559 if (ps == NULL) {
5560 Wprintf("Can't open file %s for writing.", outname);
5561 return;
5562 }
5563
5564 if ((mode != NO_SUBCIRCUITS) && (mode != ALL_PAGES))
5565 collectsubschems(areawin->page);
5566
5567 /* Check for multiple-page output: get the number of pages; */
5568 /* ignore empty pages. */
5569
5570 multipage = 0;
5571
5572 if (mode == NO_SUBCIRCUITS)
5573 pagelist = pagetotals(areawin->page, INDEPENDENT);
5574 else if (mode == ALL_PAGES)
5575 pagelist = pagetotals(areawin->page, ALL_PAGES);
5576 else
5577 pagelist = pagetotals(areawin->page, TOTAL_PAGES);
5578
5579 for (page = 0; page < xobjs.pages; page++)
5580 if (pagelist[page] > 0)
5581 multipage++;
5582
5583 if (multipage == 0) {
5584 Wprintf("Panic: could not find this page in page list!");
5585 free (pagelist);
5586 fclose(ps);
5587 return;
5588 }
5589
5590 /* Print the PostScript DSC Document Header */
5591
5592 fprintf(ps, "%%!PS-Adobe-3.0");
5593 if (multipage == 1 && !(xobjs.pagelist[areawin->page]->pmode & 1))
5594 fprintf(ps, " EPSF-3.0\n");
5595 else
5596 fprintf(ps, "\n");
5597 fprintf(ps, "%%%%Title: %s\n", fptr);
5598 fprintf(ps, "%%%%Creator: XCircuit v%2.1f rev%d\n", PROG_VERSION, PROG_REVISION);
5599 tdate = time(NULL);
5600 fprintf(ps, "%%%%CreationDate: %s", asctime(localtime(&tdate)));
5601 fprintf(ps, "%%%%Pages: %d\n", multipage);
5602
5603 /* This is just a default value; each bounding box is declared per */
5604 /* page by the DSC "PageBoundingBox" keyword. */
5605 /* However, encapsulated files adjust the bounding box to center on */
5606 /* the object, instead of centering the object on the page. */
5607
5608 if (multipage == 1 && !(xobjs.pagelist[areawin->page]->pmode & 1)) {
5609 objectptr thisobj = xobjs.pagelist[areawin->page]->pageinst->thisobject;
5610 float psscale = getpsscale(xobjs.pagelist[areawin->page]->outscale,
5611 areawin->page);
5612
5613 /* The top-level bounding box determines the size of an encapsulated */
5614 /* drawing, regardless of the PageBoundingBox numbers. Therefore, */
5615 /* we size this to bound just the picture by closing up the 1" (72 */
5616 /* PostScript units) margins, except for a tiny sliver of a margin */
5617 /* (4 PostScript units) which covers a bit of sloppiness in the font */
5618 /* measurements. */
5619
5620 fprintf(ps, "%%%%BoundingBox: 68 68 %d %d\n",
5621 (int)((float)thisobj->bbox.width * psscale)
5622 + xobjs.pagelist[areawin->page]->margins.x + 4,
5623 (int)((float)thisobj->bbox.height * psscale)
5624 + xobjs.pagelist[areawin->page]->margins.y + 4);
5625 }
5626 else if (xobjs.pagelist[0]->coordstyle == CM)
5627 fprintf(ps, "%%%%BoundingBox: 0 0 595 842\n"); /* A4 default (fixed by jdk) */
5628 else
5629 fprintf(ps, "%%%%BoundingBox: 0 0 612 792\n"); /* letter default */
5630
5631 for (i = 0; i < fontcount; i++) fontsused[i] = 0;
5632 fprintf(ps, "%%%%DocumentNeededResources: font ");
5633 stcount = 32;
5634
5635 /* find all of the fonts used in this document */
5636 /* log all fonts which are native PostScript */
5637
5638 for (curpage = 0; curpage < xobjs.pages; curpage++)
5639 if (pagelist[curpage] > 0) {
5640 writepage = xobjs.pagelist[curpage]->pageinst;
5641 findfonts(writepage->thisobject, fontsused);
5642 }
5643
5644 for (i = 0; i < fontcount; i++) {
5645 if (fontsused[i] & 0x8000)
5646 if ((fonts[i].flags & 0x8018) == 0x0) {
5647 stcount += strlen(fonts[i].psname) + 1;
5648 if (stcount > OUTPUTWIDTH) {
5649 stcount = strlen(fonts[i].psname) + 11;
5650 fprintf(ps, "\n%%%%+ font ");
5651 }
5652 fprintf(ps, "%s ", fonts[i].psname);
5653 }
5654 }
5655
5656 fprintf(ps, "\n%%%%EndComments\n");
5657
5658 tmp_s = getenv((const char *)"XCIRCUIT_LIB_DIR");
5659 if (tmp_s != NULL) {
5660 sprintf(prologue, "%s/%s", tmp_s, PROLOGUE_FILE);
5661 pro = fopen(prologue, "r");
5662 }
5663 else
5664 pro = NULL;
5665
5666 if (pro == NULL) {
5667 sprintf(prologue, "%s/%s", PROLOGUE_DIR, PROLOGUE_FILE);
5668 pro = fopen(prologue, "r");
5669 if (pro == NULL) {
5670 sprintf(prologue, "%s", PROLOGUE_FILE);
5671 pro = fopen(prologue, "r");
5672 if (pro == NULL) {
5673 Wprintf("Can't open prolog.");
5674 free(pagelist);
5675 fclose(ps);
5676 return;
5677 }
5678 }
5679 }
5680
5681 /* write the prolog to the output */
5682
5683 for(;;) {
5684 if (fgets(temp, 149, pro) == NULL) break;
5685 if (!strncmp(temp, "%%EndProlog", 11)) break;
5686 fputs(temp, ps);
5687 }
5688 fclose(pro);
5689
5690 /* Special font encodings not known to PostScript */
5691 /* (anything other than Standard and ISOLatin-1) */
5692
5693 for (findex = 0; findex < fontcount; findex++) {
5694 if ((fontsused[findex] & 0xf80) == 0x400) {
5695 /* Cyrillic (ISO8859-5) */
5696 sprintf(prologue, "%s/%s", PROLOGUE_DIR, CYRILLIC_ENC_FILE);
5697 pro = fopen(prologue, "r");
5698 if (pro == NULL) {
5699 sprintf(prologue, "%s", CYRILLIC_ENC_FILE);
5700 pro = fopen(prologue, "r");
5701 if (pro == NULL) {
5702 Wprintf("Warning: Missing font encoding vectors.");
5703 Wprintf("Output may not print properly.");
5704 }
5705 }
5706 if (pro != NULL) {
5707 for(;;) {
5708 if (fgets(temp, 149, pro) == NULL) break;
5709 fputs(temp, ps);
5710 }
5711 fclose(pro);
5712 }
5713 }
5714 else if ((fontsused[findex] & 0xf80) == 0x180) {
5715 /* Eastern European (ISOLatin2) */
5716 sprintf(prologue, "%s/%s", PROLOGUE_DIR, ISOLATIN2_ENC_FILE);
5717 pro = fopen(prologue, "r");
5718 if (pro == NULL) {
5719 sprintf(prologue, "%s", ISOLATIN2_ENC_FILE);
5720 pro = fopen(prologue, "r");
5721 if (pro == NULL) {
5722 Wprintf("Warning: Missing font encoding vectors.");
5723 Wprintf("Output may not print properly.");
5724 }
5725 }
5726 if (pro != NULL) {
5727 for(;;) {
5728 if (fgets(temp, 149, pro) == NULL) break;
5729 fputs(temp, ps);
5730 }
5731 fclose(pro);
5732 }
5733 }
5734 else if ((fontsused[findex] & 0xf80) == 0x300) {
5735 /* Turkish (ISOLatin5) */
5736 sprintf(prologue, "%s/%s", PROLOGUE_DIR, ISOLATIN5_ENC_FILE);
5737 pro = fopen(prologue, "r");
5738 if (pro == NULL) {
5739 sprintf(prologue, "%s", ISOLATIN5_ENC_FILE);
5740 pro = fopen(prologue, "r");
5741 if (pro == NULL) {
5742 Wprintf("Warning: Missing font encoding vectors.");
5743 Wprintf("Output may not print properly.");
5744 }
5745 }
5746 if (pro != NULL) {
5747 for(;;) {
5748 if (fgets(temp, 149, pro) == NULL) break;
5749 fputs(temp, ps);
5750 }
5751 fclose(pro);
5752 }
5753 }
5754 }
5755
5756 /* Finish off prolog */
5757 fputs("%%EndProlog\n", ps);
5758
5759 /* Special font handling */
5760
5761 for (findex = 0; findex < fontcount; findex++) {
5762
5763 /* Derived font slant */
5764
5765 if ((fontsused[findex] & 0x032) == 0x032)
5766 fprintf(ps, "/%s /%s .167 fontslant\n\n",
5767 fonts[findex].psname, fonts[findex].family);
5768
5769 /* Derived ISO-Latin1 encoding */
5770
5771 if ((fontsused[findex] & 0xf80) == 0x100) {
5772 char *fontorig = NULL;
5773 short i;
5774 /* find the original standard-encoded font (can be itself) */
5775 for (i = 0; i < fontcount; i++) {
5776 if (i == findex) continue;
5777 if (!strcmp(fonts[i].family, fonts[findex].family) &&
5778 ((fonts[i].flags & 0x03) == (fonts[findex].flags & 0x03))) {
5779 fontorig = fonts[i].psname;
5780 break;
5781 }
5782 }
5783 if (fontorig == NULL) fontorig = fonts[findex].psname;
5784 fprintf(ps, "/%s findfont dup length dict begin\n", fontorig);
5785 fprintf(ps, "{1 index /FID ne {def} {pop pop} ifelse} forall\n");
5786 fprintf(ps, "/Encoding ISOLatin1Encoding def currentdict end\n");
5787 fprintf(ps, "/%s exch definefont pop\n\n", fonts[findex].psname);
5788 }
5789
5790 /* Derived Cyrillic (ISO8859-5) encoding */
5791
5792 if ((fontsused[findex] & 0xf80) == 0x400) {
5793 char *fontorig = NULL;
5794 short i;
5795 /* find the original standard-encoded font (can be itself) */
5796 for (i = 0; i < fontcount; i++) {
5797 if (i == findex) continue;
5798 if (!strcmp(fonts[i].family, fonts[findex].family) &&
5799 ((fonts[i].flags & 0x03) == (fonts[findex].flags & 0x03))) {
5800 fontorig = fonts[i].psname;
5801 break;
5802 }
5803 }
5804 if (fontorig == NULL) fontorig = fonts[findex].psname;
5805 fprintf(ps, "/%s findfont dup length dict begin\n", fontorig);
5806 fprintf(ps, "{1 index /FID ne {def} {pop pop} ifelse} forall\n");
5807 fprintf(ps, "/Encoding ISO8859_5Encoding def currentdict end\n");
5808 fprintf(ps, "/%s exch definefont pop\n\n", fonts[findex].psname);
5809 }
5810
5811 /* ISO-Latin2 encoding */
5812
5813 if ((fontsused[findex] & 0xf80) == 0x180) {
5814 char *fontorig = NULL;
5815 short i;
5816 /* find the original standard-encoded font (can be itself) */
5817 for (i = 0; i < fontcount; i++) {
5818 if (i == findex) continue;
5819 if (!strcmp(fonts[i].family, fonts[findex].family) &&
5820 ((fonts[i].flags & 0x03) == (fonts[findex].flags & 0x03))) {
5821 fontorig = fonts[i].psname;
5822 break;
5823 }
5824 }
5825 if (fontorig == NULL) fontorig = fonts[findex].psname;
5826 fprintf(ps, "/%s findfont dup length dict begin\n", fontorig);
5827 fprintf(ps, "{1 index /FID ne {def} {pop pop} ifelse} forall\n");
5828 fprintf(ps, "/Encoding ISOLatin2Encoding def currentdict end\n");
5829 fprintf(ps, "/%s exch definefont pop\n\n", fonts[findex].psname);
5830 }
5831
5832 /* ISO-Latin5 encoding */
5833
5834 if ((fontsused[findex] & 0xf80) == 0x300) {
5835 char *fontorig = NULL;
5836 short i;
5837 /* find the original standard-encoded font (can be itself) */
5838 for (i = 0; i < fontcount; i++) {
5839 if (i == findex) continue;
5840 if (!strcmp(fonts[i].family, fonts[findex].family) &&
5841 ((fonts[i].flags & 0x03) == (fonts[findex].flags & 0x03))) {
5842 fontorig = fonts[i].psname;
5843 break;
5844 }
5845 }
5846 if (fontorig == NULL) fontorig = fonts[findex].psname;
5847 fprintf(ps, "/%s findfont dup length dict begin\n", fontorig);
5848 fprintf(ps, "{1 index /FID ne {def} {pop pop} ifelse} forall\n");
5849 fprintf(ps, "/Encoding ISOLatin5Encoding def currentdict end\n");
5850 fprintf(ps, "/%s exch definefont pop\n\n", fonts[findex].psname);
5851 }
5852
5853 /* To do: Special encoding */
5854
5855 if ((fontsused[findex] & 0xf80) == 0x80) {
5856 }
5857
5858 /* To do: Vectored (drawn) font */
5859
5860 if (fontsused[findex] & 0x8) {
5861 }
5862 }
5863
5864 /* List of objects already written */
5865 wroteobjs = (objectptr *) malloc (sizeof(objectptr));
5866 written = 0;
5867
5868 fprintf(ps, "%% XCircuit output starts here.\n\n");
5869 fprintf(ps, "%%%%BeginSetup\n\n");
5870
5871 /* Write out all of the images used */
5872
5873 glist = collect_graphics(pagelist);
5874 output_graphic_data(ps, glist);
5875 free(glist);
5876
5877 for (curpage = 0; curpage < xobjs.pages; curpage++) {
5878 if (pagelist[curpage] == 0) continue;
5879
5880 /* Write all of the object definitions used, bottom up */
5881 printrefobjects(ps, xobjs.pagelist[curpage]->pageinst->thisobject,
5882 &wroteobjs, &written);
5883 }
5884
5885 fprintf(ps, "\n%%%%EndSetup\n\n");
5886
5887 page = 0;
5888 for (curpage = 0; curpage < xobjs.pages; curpage++) {
5889 if (pagelist[curpage] == 0) continue;
5890
5891 /* Print the page header, all elements in the page, and page trailer */
5892 savepage = areawin->page;
5893 /* Set the current page for the duration of printing so that any */
5894 /* page parameters will be printed correctly. */
5895 areawin->page = curpage;
5896 printpageobject(ps, xobjs.pagelist[curpage]->pageinst->thisobject,
5897 ++page, curpage);
5898 areawin->page = savepage;
5899
5900 /* For crash recovery, log the filename for each page */
5901 if (mode == ALL_PAGES) {
5902 fprintf(ps, "%% %s is_filename\n",
5903 (xobjs.pagelist[curpage]->filename == NULL) ?
5904 xobjs.pagelist[curpage]->pageinst->thisobject->name :
5905 xobjs.pagelist[curpage]->filename);
5906 }
5907
5908 fprintf(ps, "\n");
5909 fflush(ps);
5910 }
5911
5912 /* For crash recovery, save all objects that have been edited but are */
5913 /* not in the list of objects already saved. */
5914
5915 if (mode == ALL_PAGES)
5916 {
5917 int i, j, k;
5918 objectptr thisobj;
5919
5920 for (i = 0; i < xobjs.numlibs; i++) {
5921 for (j = 0; j < xobjs.userlibs[i].number; j++) {
5922 thisobj = *(xobjs.userlibs[i].library + j);
5923 if (thisobj->changes > 0 ) {
5924 for (k = 0; k < written; k++)
5925 if (thisobj == *(wroteobjs + k)) break;
5926 if (k == written)
5927 printobjects(ps, thisobj, &wroteobjs, &written, DEFAULTCOLOR);
5928 }
5929 }
5930 }
5931 }
5932 else { /* No unsaved changes in these objects */
5933 setassaved(wroteobjs, written);
5934 for (i = 0; i < xobjs.pages; i++)
5935 if (pagelist[i] > 0)
5936 xobjs.pagelist[i]->pageinst->thisobject->changes = 0;
5937 xobjs.new_changes = countchanges(NULL);
5938 }
5939
5940 /* Free allocated memory */
5941 free((char *)pagelist);
5942 free((char *)wroteobjs);
5943
5944 /* Done! */
5945
5946 fprintf(ps, "%%%%Trailer\n");
5947 fprintf(ps, "XCIRCsave restore\n");
5948 fprintf(ps, "%%%%EOF\n");
5949 fclose(ps);
5950
5951 Wprintf("File %s saved (%d page%s).", fname, multipage,
5952 (multipage > 1 ? "s" : ""));
5953
5954 if (mode == ALL_PAGES) {
5955 /* Remove the temporary redundant backup */
5956 sprintf(outname, "%sB", xobjs.tempfile);
5957 unlink(outname);
5958 }
5959 else if (!xobjs.retain_backup) {
5960 /* Remove the backup file */
5961 sprintf(outname, "%s~", fname);
5962 unlink(outname);
5963 }
5964
5965 /* Write LATEX strings, if any are present */
5966 TopDoLatex();
5967 }
5968
5969 /*----------------------------------------------------------------------*/
5970 /* Given a color index, print the R, G, B values */
5971 /*----------------------------------------------------------------------*/
5972
5973 int printRGBvalues(char *tstr, int index, const char *postfix)
5974 {
5975 int i;
5976 if (index >= 0 && index < number_colors) {
5977 sprintf(tstr, "%4.3f %4.3f %4.3f %s",
5978 (float)colorlist[index].color.red / 65535,
5979 (float)colorlist[index].color.green / 65535,
5980 (float)colorlist[index].color.blue / 65535,
5981 postfix);
5982 return 0;
5983 }
5984
5985 /* The program can reach this point for any color which is */
5986 /* not listed in the table. This can happen when parameters */
5987 /* printed from printobjectparams object contain the string */
5988 /* "@p_color". Therefore print the default top-level */
5989 /* default color, which is black. */
5990
5991 /* If the index is *not* DEFAULTCOLOR (-1), return an error */
5992 /* code. */
5993
5994 sprintf(tstr, "0 0 0 %s", postfix);
5995 return (index == DEFAULTCOLOR) ? 0 : -1;
5996 }
5997
5998 /*----------------------------------------------------*/
5999 /* Write string to PostScript string, ignoring NO_OPs */
6000 /*----------------------------------------------------*/
6001
6002 char *nosprint(char *baseptr, int *margin, int *extsegs)
6003 {
6004 int qtmp, slen = 100;
6005 char *sptr, *lptr = NULL, lsave, *sptr2;
6006 u_char *pptr, *qptr, *bptr;
6007
6008 bptr = (u_char *)malloc(slen); /* initial length 100 */
6009 qptr = bptr;
6010
6011 while(1) { /* loop for breaking up margin-limited text into words */
6012
6013 if (*margin > 0) {
6014 sptr = strrchr(baseptr, ' ');
6015 if (sptr == NULL)
6016 sptr = baseptr;
6017 else {
6018 if (*(sptr + 1) == '\0') {
6019 while (*sptr == ' ') sptr--;
6020 *(sptr + 1) = '\0';
6021 sptr2 = strrchr(baseptr, ' ');
6022 *(sptr + 1) = ' ';
6023 if (sptr2 == NULL)
6024 sptr = baseptr;
6025 else
6026 sptr = sptr2 + 1;
6027 }
6028 else
6029 sptr++;
6030 }
6031 }
6032 else
6033 sptr = baseptr;
6034
6035 *qptr++ = '(';
6036
6037 /* Includes extended character set (non-ASCII) */
6038
6039 for (pptr = sptr; pptr && *pptr != '\0'; pptr++) {
6040 /* Ensure enough space for the string, including everything */
6041 /* following the "for" loop */
6042 qtmp = qptr - bptr;
6043 if (qtmp + 7 >= slen) {
6044 slen += 7;
6045 bptr = (char *)realloc(bptr, slen);
6046 qptr = bptr + qtmp;
6047 }
6048
6049 /* Deal with non-printable characters and parentheses */
6050 if (*pptr > (char)126) {
6051 sprintf(qptr, "\\%3o", (int)(*pptr));
6052 qptr += 4;
6053 }
6054 else {
6055 if ((*pptr == '(') || (*pptr == ')') || (*pptr == '\\'))
6056 *qptr++ = '\\';
6057 *qptr++ = *pptr;
6058 }
6059 }
6060 if (qptr == bptr + 1) { /* Empty string gets a NULL result, not "()" */
6061 qptr--;
6062 }
6063 else {
6064 *qptr++ = ')';
6065 *qptr++ = ' ';
6066 }
6067
6068 if (lptr != NULL)
6069 *lptr = lsave;
6070
6071 if (sptr == baseptr)
6072 break;
6073 else {
6074 lptr = sptr;
6075 lsave = *lptr;
6076 *lptr = '\0';
6077 (*extsegs)++;
6078 }
6079 }
6080
6081 *qptr++ = '\0';
6082 return (char *)bptr;
6083 }
6084
6085 /*--------------------------------------------------------------*/
6086 /* Write label segments to the output (in reverse order) */
6087 /*--------------------------------------------------------------*/
6088
6089 short writelabel(FILE *ps, stringpart *chrtop, short *stcount)
6090 {
6091 short i, segs = 0;
6092 stringpart *chrptr;
6093 char **ostr = (char **)malloc(sizeof(char *));
6094 char *tmpstr;
6095 float lastscale = 1.0;
6096 int lastfont = -1;
6097 int margin = 0;
6098 int extsegs = 0;
6099
6100 /* Write segments into string array, in forward order */
6101
6102 for (chrptr = chrtop; chrptr != NULL; chrptr = chrptr->nextpart) {
6103 ostr = (char **)realloc(ostr, (segs + 1) * sizeof(char *));
6104 if (chrtop->type == PARAM_END) { /* NULL parameter is empty string */
6105 ostr[segs] = (char *)malloc(4);
6106 strcpy(ostr[segs], "() ");
6107 }
6108 else {
6109 tmpstr = writesegment(chrptr, &lastscale, &lastfont, &margin, &extsegs);
6110 if (tmpstr[0] != '\0')
6111 ostr[segs] = tmpstr;
6112 else
6113 segs--;
6114 }
6115 segs++;
6116 }
6117
6118 /* Write string array to output in reverse order */
6119 for (i = segs - 1; i >= 0; i--) {
6120 dostcount(ps, stcount, strlen(ostr[i]));
6121 fputs(ostr[i], ps);
6122 free(ostr[i]);
6123 }
6124 free(ostr);
6125
6126 return segs + extsegs;
6127 }
6128
6129 /*--------------------------------------------------------------*/
6130 /* Write a single label segment to the output */
6131 /* (Recursive, so we can write segments in the reverse order) */
6132 /*--------------------------------------------------------------*/
6133
6134 char *writesegment(stringpart *chrptr, float *lastscale, int *lastfont, int *margin,
6135 int *extsegs)
6136 {
6137 int type = chrptr->type;
6138 char *retstr, *validname;
6139
6140 switch(type) {
6141 case PARAM_START:
6142 validname = create_valid_psname(chrptr->data.string, TRUE);
6143 sprintf(_STR, "%s ", validname);
6144 break;
6145 case PARAM_END:
6146 _STR[0] = '\0';
6147 chrptr->nextpart = NULL;
6148 break;
6149 case SUBSCRIPT:
6150 sprintf(_STR, "{ss} ");
6151 break;
6152 case SUPERSCRIPT:
6153 sprintf(_STR, "{Ss} ");
6154 break;
6155 case NORMALSCRIPT:
6156 *lastscale = 1.0;
6157 sprintf(_STR, "{ns} ");
6158 break;
6159 case UNDERLINE:
6160 sprintf(_STR, "{ul} ");
6161 break;
6162 case OVERLINE:
6163 sprintf(_STR, "{ol} ");
6164 break;
6165 case NOLINE:
6166 sprintf(_STR, "{} ");
6167 break;
6168 case HALFSPACE:
6169 sprintf(_STR, "{hS} ");
6170 break;
6171 case QTRSPACE:
6172 sprintf(_STR, "{qS} ");
6173 break;
6174 case RETURN:
6175 *lastscale = 1.0;
6176 if (chrptr->data.flags == 0)
6177 // Ignore automatically-generated line breaks
6178 sprintf(_STR, "{CR} ");
6179 else
6180 sprintf(_STR, "");
6181 break;
6182 case TABSTOP:
6183 sprintf(_STR, "{Ts} ");
6184 break;
6185 case TABFORWARD:
6186 sprintf(_STR, "{Tf} ");
6187 break;
6188 case TABBACKWARD:
6189 sprintf(_STR, "{Tb} ");
6190 break;
6191 case FONT_NAME:
6192 /* If font specifier is followed by a scale specifier, then */
6193 /* record the font change but defer the output. Otherwise, */
6194 /* output the font record now. */
6195
6196 if ((chrptr->nextpart == NULL) || (chrptr->nextpart->type != FONT_SCALE))
6197 {
6198 if (*lastscale == 1.0)
6199 sprintf(_STR, "{/%s cf} ", fonts[chrptr->data.font].psname);
6200 else
6201 sprintf(_STR, "{/%s %5.3f cf} ", fonts[chrptr->data.font].psname,
6202 *lastscale);
6203 }
6204 else
6205 _STR[0] = '\0';
6206 *lastfont = chrptr->data.font;
6207 break;
6208 case FONT_SCALE:
6209 if (*lastfont == -1) {
6210 Fprintf(stderr, "Warning: Font may not be the one that was intended.\n");
6211 *lastfont = 0;
6212 }
6213 *lastscale = chrptr->data.scale;
6214 sprintf(_STR, "{/%s %5.3f cf} ", fonts[*lastfont].psname, *lastscale);
6215 break;
6216 case FONT_COLOR:
6217 strcpy(_STR, "{");
6218 if (chrptr->data.color == DEFAULTCOLOR)
6219 strcat(_STR, "sce} ");
6220 else
6221 if (printRGBvalues(_STR + 1, chrptr->data.color, "scb} ") < 0)
6222 strcat(_STR, "sce} ");
6223 break;
6224 case MARGINSTOP:
6225 sprintf(_STR, "{%d MR} ", chrptr->data.width);
6226 *margin = chrptr->data.width;
6227 break;
6228 case KERN:
6229 sprintf(_STR, "{%d %d Kn} ", chrptr->data.kern[0], chrptr->data.kern[1]);
6230 break;
6231 case TEXT_STRING:
6232 /* Everything except TEXT_STRING will always fit in the _STR fixed- */
6233 /* length character array. */
6234 return nosprint(chrptr->data.string, margin, extsegs);
6235 }
6236
6237 retstr = (char *)malloc(1 + strlen(_STR));
6238 strcpy(retstr, _STR);
6239 return retstr;
6240 }
6241
6242 /*--------------------------------------------------------------*/
6243 /* Routine to write all the label segments as stored in _STR */
6244 /*--------------------------------------------------------------*/
6245
6246 int writelabelsegs(FILE *ps, short *stcount, stringpart *chrptr)
6247 {
6248 Boolean ismultipart;
6249 int segs;
6250
6251 if (chrptr == NULL) return 0;
6252
6253 ismultipart = ((chrptr->nextpart != NULL) &&
6254 (chrptr->nextpart->type != PARAM_END)) ? True : False;
6255
6256 /* If there is only one part, but it is not a string or the */
6257 /* end of a parameter (empty parameter), then set multipart */
6258 /* anyway so we get the double brace {{ }}. */
6259
6260 if ((!ismultipart) && (chrptr->type != TEXT_STRING) &&
6261 (chrptr->type != PARAM_END))
6262 ismultipart = True;
6263
6264 /* nextpart is not NULL if there are multiple parts to the string */
6265 if (ismultipart) {
6266 fprintf(ps, "{");
6267 (*stcount)++;
6268 }
6269 segs = writelabel(ps, chrptr, stcount);
6270
6271 if (ismultipart) {
6272 fprintf(ps, "} ");
6273 (*stcount) += 2;
6274 }
6275 return segs;
6276 }
6277
6278 /*--------------------------------------------------------------*/
6279 /* Write the dictionary of parameters belonging to an object */
6280 /*--------------------------------------------------------------*/
6281
6282 void printobjectparams(FILE *ps, objectptr localdata)
6283 {
6284 int segs;
6285 short stcount;
6286 oparamptr ops;
6287 char *ps_expr, *validkey;
6288 float fp;
6289
6290 /* Check for parameters and default values */
6291 if (localdata->params == NULL) return;
6292
6293 fprintf(ps, "<<");
6294 stcount = 2;
6295
6296 for (ops = localdata->params; ops != NULL; ops = ops->next) {
6297 validkey = create_valid_psname(ops->key, TRUE);
6298 fprintf(ps, "/%s ", validkey);
6299 dostcount (ps, &stcount, strlen(validkey) + 2);
6300
6301 switch (ops->type) {
6302 case XC_EXPR:
6303 ps_expr = evaluate_expr(localdata, ops, NULL);
6304 if (ops->which == P_SUBSTRING || ops->which == P_EXPRESSION) {
6305 dostcount(ps, &stcount, 3 + strlen(ps_expr));
6306 fputs("(", ps);
6307 fputs(ps_expr, ps);
6308 fputs(") ", ps);
6309 }
6310 else if (ops->which == P_COLOR) {
6311 int ccol;
6312 /* Write R, G, B components for PostScript */
6313 if (sscanf(ps_expr, "%d", &ccol) == 1) {
6314 fputs("{", ps);
6315 printRGBvalues(_STR, ccol, "} ");
6316 dostcount(ps, &stcount, 1 + strlen(_STR));
6317 fputs(_STR, ps);
6318 }
6319 else {
6320 dostcount(ps, &stcount, 8);
6321 fputs("{0 0 0} ", ps);
6322 }
6323 }
6324 else if (sscanf(ps_expr, "%g", &fp) == 1) {
6325 dostcount(ps, &stcount, 1 + strlen(ps_expr));
6326 fputs(ps_expr, ps);
6327 fputs(" ", ps);
6328 }
6329 else { /* Expression evaluates to error in object */
6330 dostcount(ps, &stcount, 2);
6331 fputs("0 ", ps);
6332 }
6333 dostcount(ps, &stcount, 7 + strlen(ops->parameter.expr));
6334 fputs("(", ps);
6335 fputs(ops->parameter.expr, ps);
6336 fputs(") pop ", ps);
6337 free(ps_expr);
6338 break;
6339 case XC_STRING:
6340 segs = writelabelsegs(ps, &stcount, ops->parameter.string);
6341 if (segs == 0) {
6342 /* When writing object parameters, we cannot allow a */
6343 /* NULL value. Instead, print an empty string (). */
6344 dostcount(ps, &stcount, 3);
6345 fputs("() ", ps);
6346 }
6347 break;
6348 case XC_INT:
6349 sprintf(_STR, "%d ", ops->parameter.ivalue);
6350 dostcount(ps, &stcount, strlen(_STR));
6351 fputs(_STR, ps);
6352 break;
6353 case XC_FLOAT:
6354 sprintf(_STR, "%g ", ops->parameter.fvalue);
6355 dostcount(ps, &stcount, strlen(_STR));
6356 fputs(_STR, ps);
6357 break;
6358 }
6359 }
6360
6361 fprintf(ps, ">> ");
6362 dostcount (ps, &stcount, 3);
6363 }
6364
6365 /*--------------------------------------------------------------*/
6366 /* Write the list of parameters belonging to an object instance */
6367 /*--------------------------------------------------------------*/
6368
6369 short printparams(FILE *ps, objinstptr sinst, short stcount)
6370 {
6371 int segs;
6372 short loccount;
6373 oparamptr ops, objops;
6374 eparamptr epp;
6375 char *ps_expr, *validkey, *validref;
6376 short instances = 0;
6377
6378 if (sinst->params == NULL) return stcount;
6379
6380 for (ops = sinst->params; ops != NULL; ops = ops->next) {
6381 validref = strdup(create_valid_psname(ops->key, TRUE));
6382
6383 /* Check for indirect parameter references */
6384 for (epp = sinst->passed; epp != NULL; epp = epp->next) {
6385 if ((epp->flags & P_INDIRECT) && (epp->pdata.refkey != NULL)) {
6386 if (!strcmp(epp->pdata.refkey, ops->key)) {
6387 if (instances++ == 0) {
6388 fprintf(ps, "<<"); /* begin PostScript dictionary */
6389 loccount = stcount + 2;
6390 }
6391 dostcount(ps, &loccount, strlen(validref + 3));
6392 fprintf(ps, "/%s ", validref);
6393 dostcount(ps, &loccount, strlen(epp->key + 1));
6394 validkey = create_valid_psname(epp->key, TRUE);
6395 fprintf(ps, "%s ", validkey);
6396 break;
6397 }
6398 }
6399 }
6400 if (epp == NULL) { /* No indirection */
6401 Boolean nondefault = TRUE;
6402 char *deflt_expr = NULL;
6403
6404 /* For instance values that are expression results, ignore if */
6405 /* the instance value is the same as the default value. */
6406 /* Correction 9/08: We can't second-guess expression results, */
6407 /* in particular, this doesn't work for an expression like */
6408 /* "page", where the local and default values will evaluate to */
6409 /* the same result, when clearly each page is intended to have */
6410 /* its own instance value, and "page" for an object is not a */
6411 /* well-defined concept. */
6412
6413 // ps_expr = NULL;
6414 // objops = match_param(sinst->thisobject, ops->key);
6415 // if (objops && (objops->type == XC_EXPR)) {
6416 // int i;
6417 // float f;
6418 // deflt_expr = evaluate_expr(sinst->thisobject, objops, NULL);
6419 // switch (ops->type) {
6420 // case XC_STRING:
6421 // if (!textcomp(ops->parameter.string, deflt_expr, sinst))
6422 // nondefault = FALSE;
6423 // break;
6424 // case XC_EXPR:
6425 // ps_expr = evaluate_expr(sinst->thisobject, ops, sinst);
6426 // if (!strcmp(ps_expr, deflt_expr)) nondefault = FALSE;
6427 // break;
6428 // case XC_INT:
6429 // sscanf(deflt_expr, "%d", &i);
6430 // if (i == ops->parameter.ivalue) nondefault = FALSE;
6431 // break;
6432 // case XC_FLOAT:
6433 // sscanf(deflt_expr, "%g", &f);
6434 // if (f == ops->parameter.fvalue) nondefault = FALSE;
6435 // break;
6436 // }
6437 // if (deflt_expr) free(deflt_expr);
6438 // if (nondefault == FALSE) {
6439 // if (ps_expr) free(ps_expr);
6440 // continue;
6441 // }
6442 // }
6443
6444 if (instances++ == 0) {
6445 fprintf(ps, "<<"); /* begin PostScript dictionary */
6446 loccount = stcount + 2;
6447 }
6448 dostcount(ps, &loccount, strlen(validref) + 2);
6449 fprintf(ps, "/%s ", validref);
6450
6451 switch (ops->type) {
6452 case XC_STRING:
6453 segs = writelabelsegs(ps, &loccount, ops->parameter.string);
6454 if (segs == 0) {
6455 /* When writing object parameters, we cannot allow a */
6456 /* NULL value. Instead, print an empty string (). */
6457 dostcount(ps, &stcount, 3);
6458 fputs("() ", ps);
6459 }
6460 break;
6461 case XC_EXPR:
6462 ps_expr = evaluate_expr(sinst->thisobject, ops, sinst);
6463 dostcount(ps, &loccount, 3 + strlen(ps_expr));
6464 fputs("(", ps);
6465 fputs(ps_expr, ps);
6466 fputs(") ", ps);
6467 free(ps_expr);
6468
6469 /* The instance parameter expression may have the */
6470 /* same expression as the object but a different */
6471 /* result if the expression uses another parameter. */
6472 /* Only print the expression itself if it's different */
6473 /* from the object's expression. */
6474
6475 objops = match_param(sinst->thisobject, ops->key);
6476 if (objops && strcmp(ops->parameter.expr, objops->parameter.expr)) {
6477 dostcount(ps, &loccount, 3 + strlen(ops->parameter.expr));
6478 fputs("(", ps);
6479 fputs(ops->parameter.expr, ps);
6480 fputs(") pop ", ps);
6481 }
6482 break;
6483 case XC_INT:
6484 if (ops->which == P_COLOR) {
6485 /* Write R, G, B components */
6486 _STR[0] = '{';
6487 printRGBvalues(_STR + 1, ops->parameter.ivalue, "} ");
6488 }
6489 else
6490 sprintf(_STR, "%d ", ops->parameter.ivalue);
6491 dostcount(ps, &loccount, strlen(_STR));
6492 fputs(_STR, ps);
6493 break;
6494 case XC_FLOAT:
6495 sprintf(_STR, "%g ", ops->parameter.fvalue);
6496 dostcount(ps, &loccount, strlen(_STR));
6497 fputs(_STR, ps);
6498 break;
6499 }
6500 }
6501 free(validref);
6502 }
6503 if (instances > 0) {
6504 fprintf(ps, ">> "); /* end PostScript dictionary */
6505 loccount += 3;
6506 }
6507 return loccount;
6508 }
6509
6510 /*------------------------------------------------------------------*/
6511 /* Macro for point output (calls varpcheck() on x and y components) */
6512 /*------------------------------------------------------------------*/
6513
6514 #define xyvarcheck(z, n, t) \
6515 varpcheck(ps, (z).x, localdata, n, &stcount, *(t), P_POSITION_X); \
6516 varpcheck(ps, (z).y, localdata, n, &stcount, *(t), P_POSITION_Y)
6517
6518 #define xypathcheck(z, n, t, p) \
6519 varpathcheck(ps, (z).x, localdata, n, &stcount, t, TOPATH(p), P_POSITION_X); \
6520 varpathcheck(ps, (z).y, localdata, n, &stcount, t, TOPATH(p), P_POSITION_Y)
6521
6522 /*--------------------------------------------------------------*/
6523 /* Main routine for writing the contents of a single object to */
6524 /* output file "ps". */
6525 /*--------------------------------------------------------------*/
6526
6527 void printOneObject(FILE *ps, objectptr localdata, int ccolor)
6528 {
6529 int i, curcolor = ccolor;
6530 genericptr *savegen, *pgen;
6531 objinstptr sobj;
6532 graphicptr sg;
6533 Imagedata *img;
6534 pointlist savept;
6535 short stcount;
6536 short segs;
6537 Boolean has_parameter;
6538 char *fptr, *validname;
6539
6540 /* first, get a total count of all objects and give warning if large */
6541
6542 if ((is_page(localdata) == -1) && (localdata->parts > 255)) {
6543 Wprintf("Warning: \"%s\" may exceed printer's PS limit for definitions",
6544 localdata->name);
6545 }
6546
6547 for (savegen = localdata->plist; savegen < localdata->plist +
6548 localdata->parts; savegen++) {
6549
6550 /* Check if this color is parameterized */
6551 eparamptr epp;
6552 oparamptr ops;
6553
6554 /* FIXEDBBOX style is handled in the object header and */
6555 /* the part should be skipped. */
6556
6557 if (ELEMENTTYPE(*savegen) == POLYGON)
6558 if (TOPOLY(savegen)->style & FIXEDBBOX)
6559 continue;
6560
6561 for (epp = (*savegen)->passed; epp != NULL; epp = epp->next) {
6562 ops = match_param(localdata, epp->key);
6563 if (ops != NULL && (ops->which == P_COLOR)) {
6564 /* Ensure that the next element forces a color change */
6565 curcolor = ERRORCOLOR;
6566 sprintf(_STR, "%s scb\n", epp->key);
6567 fputs(_STR, ps);
6568 break;
6569 }
6570 }
6571
6572 /* Enforce the rule that clipmasks must always be DEFAULTCOLOR */
6573
6574 switch(ELEMENTTYPE(*savegen)) {
6575 case POLYGON: case SPLINE: case ARC: case PATH:
6576 if (TOPOLY(savegen)->style & CLIPMASK)
6577 (*savegen)->color = DEFAULTCOLOR;
6578 break;
6579 }
6580
6581 /* change current color if different */
6582
6583 if ((epp == NULL) && ((*savegen)->color != curcolor)) {
6584 if ((curcolor = (*savegen)->color) == DEFAULTCOLOR)
6585 fprintf(ps, "sce\n");
6586 else {
6587 if (printRGBvalues(_STR, (*savegen)->color, "scb\n") < 0) {
6588 fprintf(ps, "sce\n");
6589 curcolor = DEFAULTCOLOR;
6590 }
6591 else
6592 fputs(_STR, ps);
6593 }
6594 }
6595
6596 stcount = 0;
6597 switch(ELEMENTTYPE(*savegen)) {
6598
6599 case(POLYGON):
6600 varcheck(ps, TOPOLY(savegen)->style, localdata, &stcount,
6601 *savegen, P_STYLE);
6602 varfcheck(ps, TOPOLY(savegen)->width, localdata, &stcount,
6603 *savegen, P_LINEWIDTH);
6604 for (savept = TOPOLY(savegen)->points; savept < TOPOLY(savegen)->
6605 points + TOPOLY(savegen)->number; savept++) {
6606 varpcheck(ps, savept->x, localdata,
6607 savept - TOPOLY(savegen)->points, &stcount, *savegen,
6608 P_POSITION_X);
6609 varpcheck(ps, savept->y, localdata,
6610 savept - TOPOLY(savegen)->points, &stcount, *savegen,
6611 P_POSITION_Y);
6612 }
6613 sprintf(_STR, "%hd ", TOPOLY(savegen)->number);
6614 dostcount (ps, &stcount, strlen(_STR));
6615 fputs(_STR, ps);
6616 if (varpcheck(ps, 0, localdata, -1, &stcount, *savegen,
6617 P_POSITION_X)) {
6618 sprintf(_STR, "addtox ");
6619 dostcount (ps, &stcount, strlen(_STR));
6620 fputs(_STR, ps);
6621 }
6622 if (varpcheck(ps, 0, localdata, -1, &stcount, *savegen,
6623 P_POSITION_Y)) {
6624 sprintf(_STR, "addtoy ");
6625 dostcount (ps, &stcount, strlen(_STR));
6626 fputs(_STR, ps);
6627 }
6628 sprintf(_STR, "polygon\n");
6629 dostcount (ps, &stcount, strlen(_STR));
6630 fputs(_STR, ps);
6631 break;
6632
6633 case(PATH):
6634 pgen = TOPATH(savegen)->plist;
6635 switch(ELEMENTTYPE(*pgen)) {
6636 case POLYGON:
6637 xypathcheck(TOPOLY(pgen)->points[0], 0, pgen, savegen);
6638 break;
6639 case SPLINE:
6640 xypathcheck(TOSPLINE(pgen)->ctrl[0], 0, pgen, savegen);
6641 break;
6642 }
6643 dostcount(ps, &stcount, 9);
6644 if (varpathcheck(ps, 0, localdata, -1, &stcount, pgen,
6645 TOPATH(savegen), P_POSITION_X)) {
6646 sprintf(_STR, "addtox1 ");
6647 dostcount (ps, &stcount, strlen(_STR));
6648 fputs(_STR, ps);
6649 }
6650 if (varpathcheck(ps, 0, localdata, -1, &stcount, pgen,
6651 TOPATH(savegen), P_POSITION_Y)) {
6652 sprintf(_STR, "addtoy1 ");
6653 dostcount (ps, &stcount, strlen(_STR));
6654 fputs(_STR, ps);
6655 }
6656 fprintf(ps, "beginpath\n");
6657 for (pgen = TOPATH(savegen)->plist; pgen < TOPATH(savegen)->plist
6658 + TOPATH(savegen)->parts; pgen++) {
6659 switch(ELEMENTTYPE(*pgen)) {
6660 case POLYGON:
6661 for (savept = TOPOLY(pgen)->points + TOPOLY(pgen)->number
6662 - 1; savept > TOPOLY(pgen)->points; savept--) {
6663 xypathcheck(*savept, savept - TOPOLY(pgen)->points, pgen,
6664 savegen);
6665 }
6666 sprintf(_STR, "%hd ", TOPOLY(pgen)->number - 1);
6667 dostcount (ps, &stcount, strlen(_STR));
6668 fputs(_STR, ps);
6669 if (varpathcheck(ps, 0, localdata, -1, &stcount, pgen,
6670 TOPATH(savegen), P_POSITION_X)) {
6671 sprintf(_STR, "addtox ");
6672 dostcount (ps, &stcount, strlen(_STR));
6673 fputs(_STR, ps);
6674 }
6675 if (varpathcheck(ps, 0, localdata, -1, &stcount, pgen,
6676 TOPATH(savegen), P_POSITION_Y)) {
6677 sprintf(_STR, "addtoy ");
6678 dostcount (ps, &stcount, strlen(_STR));
6679 fputs(_STR, ps);
6680 }
6681 sprintf(_STR, "polyc\n");
6682 dostcount (ps, &stcount, strlen(_STR));
6683 fputs(_STR, ps);
6684 break;
6685 case SPLINE:
6686 xypathcheck(TOSPLINE(pgen)->ctrl[1], 1, pgen, savegen);
6687 xypathcheck(TOSPLINE(pgen)->ctrl[2], 2, pgen, savegen);
6688 xypathcheck(TOSPLINE(pgen)->ctrl[3], 3, pgen, savegen);
6689 if (varpathcheck(ps, 0, localdata, -1, &stcount, pgen,
6690 TOPATH(savegen), P_POSITION_X)) {
6691 sprintf(_STR, "addtox3 ");
6692 dostcount (ps, &stcount, strlen(_STR));
6693 fputs(_STR, ps);
6694 }
6695 if (varpathcheck(ps, 0, localdata, -1, &stcount, pgen,
6696 TOPATH(savegen), P_POSITION_Y)) {
6697 sprintf(_STR, "addtoy3 ");
6698 dostcount (ps, &stcount, strlen(_STR));
6699 fputs(_STR, ps);
6700 }
6701 fprintf(ps, "curveto\n");
6702 break;
6703 }
6704 }
6705 varcheck(ps, TOPATH(savegen)->style, localdata, &stcount,
6706 *savegen, P_STYLE);
6707 varfcheck(ps, TOPATH(savegen)->width, localdata, &stcount,
6708 *savegen, P_LINEWIDTH);
6709 fprintf(ps, "endpath\n");
6710 break;
6711
6712 case(SPLINE):
6713 varcheck(ps, TOSPLINE(savegen)->style, localdata, &stcount,
6714 *savegen, P_STYLE);
6715 varfcheck(ps, TOSPLINE(savegen)->width, localdata, &stcount,
6716 *savegen, P_LINEWIDTH);
6717 xyvarcheck(TOSPLINE(savegen)->ctrl[1], 1, savegen);
6718 xyvarcheck(TOSPLINE(savegen)->ctrl[2], 2, savegen);
6719 xyvarcheck(TOSPLINE(savegen)->ctrl[3], 3, savegen);
6720 xyvarcheck(TOSPLINE(savegen)->ctrl[0], 0, savegen);
6721 if (varpcheck(ps, 0, localdata, -1, &stcount, *savegen,
6722 P_POSITION_X)) {
6723 sprintf(_STR, "addtox4 ");
6724 dostcount (ps, &stcount, strlen(_STR));
6725 fputs(_STR, ps);
6726 }
6727 if (varpcheck(ps, 0, localdata, -1, &stcount, *savegen,
6728 P_POSITION_Y)) {
6729 sprintf(_STR, "addtoy4 ");
6730 dostcount (ps, &stcount, strlen(_STR));
6731 fputs(_STR, ps);
6732 }
6733 fprintf(ps, "spline\n");
6734 break;
6735
6736 case(ARC):
6737 varcheck(ps, TOARC(savegen)->style, localdata, &stcount,
6738 *savegen, P_STYLE);
6739 varfcheck(ps, TOARC(savegen)->width, localdata, &stcount,
6740 *savegen, P_LINEWIDTH);
6741 xyvarcheck(TOARC(savegen)->position, 0, savegen);
6742 varcheck(ps, abs(TOARC(savegen)->radius), localdata, &stcount,
6743 *savegen, P_RADIUS);
6744 if (abs(TOARC(savegen)->radius) == TOARC(savegen)->yaxis) {
6745 varfcheck(ps, TOARC(savegen)->angle1, localdata, &stcount,
6746 *savegen, P_ANGLE1);
6747 varfcheck(ps, TOARC(savegen)->angle2, localdata, &stcount,
6748 *savegen, P_ANGLE2);
6749 fprintf(ps, "xcarc\n");
6750 }
6751 else {
6752 varcheck(ps, abs(TOARC(savegen)->yaxis), localdata, &stcount,
6753 *savegen, P_MINOR_AXIS);
6754 varfcheck(ps, TOARC(savegen)->angle1, localdata, &stcount,
6755 *savegen, P_ANGLE1);
6756 varfcheck(ps, TOARC(savegen)->angle2, localdata, &stcount,
6757 *savegen, P_ANGLE2);
6758 fprintf(ps, "ellipse\n");
6759 }
6760 break;
6761
6762 case(OBJINST):
6763 sobj = TOOBJINST(savegen);
6764 varfcheck(ps, sobj->scale, localdata, &stcount, *savegen, P_SCALE);
6765 if (!(sobj->style & LINE_INVARIANT)) fprintf(ps, "/sv ");
6766 varfcheck(ps, sobj->rotation, localdata, &stcount, *savegen, P_ROTATION);
6767 xyvarcheck(sobj->position, 0, savegen);
6768
6769 opsubstitute(sobj->thisobject, sobj);
6770 stcount = printparams(ps, sobj, stcount);
6771
6772 validname = create_valid_psname(sobj->thisobject->name, FALSE);
6773
6774 /* Names without technologies get a leading string '::' */
6775 /* (blank technology) */
6776
6777 if (strstr(validname, "::") == NULL)
6778 fprintf(ps, "::%s\n", validname);
6779 else
6780 fprintf(ps, "%s\n", validname);
6781 break;
6782
6783 case(GRAPHIC):
6784 sg = TOGRAPHIC(savegen);
6785 for (i = 0; i < xobjs.images; i++) {
6786 img = xobjs.imagelist + i;
6787 if (img->image == sg->source)
6788 break;
6789 }
6790
6791 fptr = strrchr(img->filename, '/');
6792 if (fptr == NULL)
6793 fptr = img->filename;
6794 else
6795 fptr++;
6796 fprintf(ps, "/%s ", fptr);
6797 stcount += (2 + strlen(fptr));
6798
6799 varfcheck(ps, sg->scale, localdata, &stcount, *savegen, P_SCALE);
6800 varfcheck(ps, sg->rotation, localdata, &stcount, *savegen, P_ROTATION);
6801 xyvarcheck(sg->position, 0, savegen);
6802 fprintf(ps, "graphic\n");
6803 break;
6804
6805 case(LABEL):
6806
6807 /* Don't save temporary labels from schematic capture system */
6808 if (TOLABEL(savegen)->string->type != FONT_NAME) break;
6809
6810 /* Check for parameter --- must use "mark" to count # segments */
6811 has_parameter = hasparameter(TOLABEL(savegen));
6812
6813 if (has_parameter) {
6814 fprintf(ps, "mark ");
6815 stcount += 5;
6816 }
6817
6818 segs = writelabel(ps, TOLABEL(savegen)->string, &stcount);
6819
6820 if (segs > 0) {
6821 if (has_parameter)
6822 sprintf(_STR, "ctmk ");
6823 else
6824 sprintf(_STR, "%hd ", segs);
6825 dostcount(ps, &stcount, strlen(_STR));
6826 fputs(_STR, ps);
6827 varcheck(ps, TOLABEL(savegen)->anchor, localdata, &stcount,
6828 *savegen, P_ANCHOR);
6829 varfcheck(ps, TOLABEL(savegen)->rotation, localdata, &stcount,
6830 *savegen, P_ROTATION);
6831 varfcheck(ps, TOLABEL(savegen)->scale, localdata, &stcount,
6832 *savegen, P_SCALE);
6833 xyvarcheck(TOLABEL(savegen)->position, 0, savegen);
6834
6835 switch(TOLABEL(savegen)->pin) {
6836 case LOCAL:
6837 strcpy(_STR, "pinlabel\n"); break;
6838 case GLOBAL:
6839 strcpy(_STR, "pinglobal\n"); break;
6840 case INFO:
6841 strcpy(_STR, "infolabel\n"); break;
6842 default:
6843 strcpy(_STR, "label\n");
6844 }
6845 dostcount(ps, &stcount, strlen(_STR));
6846 fputs(_STR, ps);
6847 }
6848 break;
6849 }
6850 }
6851 }
6852
6853 /*----------------------------------------------------------------------*/
6854 /* Recursive routine to print out the library objects used in this */
6855 /* drawing, starting at the bottom of the object hierarchy so that each */
6856 /* object is defined before it is called. A list of objects already */
6857 /* written is maintained so that no object is written twice. */
6858 /* */
6859 /* When object "localdata" is not a top-level page, call this routine */
6860 /* with mpage=-1 (simpler than checking whether localdata is a page). */
6861 /*----------------------------------------------------------------------*/
6862
6863 void printobjects(FILE *ps, objectptr localdata, objectptr **wrotelist,
6864 short *written, int ccolor)
6865 {
6866 genericptr *gptr, *savegen;
6867 objectptr *optr;
6868 /* oparamptr ops; (jdk) */
6869 char *validname;
6870 int curcolor = ccolor;
6871 /* int libno; (jdk) */
6872
6873 /* Search among the list of objects already written to the output */
6874 /* If this object has been written previously, then we ignore it. */
6875
6876 for (optr = *wrotelist; optr < *wrotelist + *written; optr++)
6877 if (*optr == localdata)
6878 return;
6879
6880 /* If this page is a schematic, write out the definiton of any symbol */
6881 /* attached to it, because that symbol may not be used anywhere else. */
6882
6883 if (localdata->symschem && (localdata->schemtype == PRIMARY))
6884 printobjects(ps, localdata->symschem, wrotelist, written, curcolor);
6885
6886 /* Search for all object definitions instantiated in this object, */
6887 /* and (recursively) print them to the output. */
6888
6889 for (gptr = localdata->plist; gptr < localdata->plist + localdata->parts; gptr++)
6890 if (IS_OBJINST(*gptr))
6891 printobjects(ps, TOOBJINST(gptr)->thisobject, wrotelist, written, curcolor);
6892
6893 /* Update the list of objects already written to the output */
6894
6895 *wrotelist = (objectptr *)realloc(*wrotelist, (*written + 1) *
6896 sizeof(objectptr));
6897 *(*wrotelist + *written) = localdata;
6898 (*written)++;
6899
6900 validname = create_valid_psname(localdata->name, FALSE);
6901 if (strstr(validname, "::") == NULL)
6902 fprintf(ps, "/::%s {\n", validname);
6903 else
6904 fprintf(ps, "/%s {\n", validname);
6905
6906 /* Write a "bbox" record if there is an element with style FIXEDBBOX */
6907 /* This is the only time a "bbox" record is written for an object. */
6908
6909 for (savegen = localdata->plist; savegen < localdata->plist +
6910 localdata->parts; savegen++) {
6911 if (ELEMENTTYPE(*savegen) == POLYGON) {
6912 if (TOPOLY(savegen)->style & FIXEDBBOX) {
6913 pointlist polypoints;
6914 int width, height;
6915 polypoints = TOPOLY(savegen)->points + 2;
6916 width = polypoints->x;
6917 height = polypoints->y;
6918 polypoints = TOPOLY(savegen)->points;
6919 width -= polypoints->x;
6920 height -= polypoints->y;
6921 fprintf(ps, "%% %d %d %d %d bbox\n",
6922 polypoints->x, polypoints->y,
6923 width, height);
6924 break;
6925 }
6926 }
6927 }
6928
6929 if (localdata->hidden == True) fprintf(ps, "%% hidden\n");
6930
6931 /* For symbols with schematics, and "trivial" schematics */
6932 if (localdata->symschem != NULL)
6933 fprintf(ps, "%% %s is_schematic\n", localdata->symschem->name);
6934 else if (localdata->schemtype == TRIVIAL)
6935 fprintf(ps, "%% trivial\n");
6936 else if (localdata->schemtype == NONETWORK)
6937 fprintf(ps, "%% nonetwork\n");
6938
6939 printobjectparams(ps, localdata);
6940 fprintf(ps, "begingate\n");
6941
6942 /* Write all the elements in order */
6943
6944 opsubstitute(localdata, NULL);
6945 printOneObject(ps, localdata, curcolor);
6946
6947 /* Write object (gate) trailer */
6948
6949 fprintf(ps, "endgate\n} def\n\n");
6950 }
6951
6952 /*--------------------------------------------------------------*/
6953 /* Print a page header followed by everything in the page. */
6954 /* this routine assumes that all objects used by the page have */
6955 /* already been handled and written to the output. */
6956 /* */
6957 /* "page" is the page number, counting consecutively from one. */
6958 /* "mpage" is the page number in xcircuit's pagelist structure. */
6959 /*--------------------------------------------------------------*/
6960
6961 void printpageobject(FILE *ps, objectptr localdata, short page, short mpage)
6962 {
6963 /* genericptr *gptr; (jdk) */
6964 XPoint origin, corner;
6965 objinstptr writepage;
6966 int width, height;
6967 float psnorm, psscale;
6968 float xmargin, ymargin;
6969 char *rootptr = NULL;
6970 polyptr framebox;
6971
6972 /* Output page header information */
6973
6974 if (xobjs.pagelist[mpage]->filename)
6975 rootptr = strrchr(xobjs.pagelist[mpage]->filename, '/');
6976 if (rootptr == NULL)
6977 rootptr = xobjs.pagelist[mpage]->filename;
6978 else rootptr++;
6979
6980 writepage = xobjs.pagelist[mpage]->pageinst;
6981
6982 psnorm = xobjs.pagelist[mpage]->outscale;
6983 psscale = getpsscale(psnorm, mpage);
6984
6985 /* Determine the margins (offset of drawing from page corner) */
6986 /* If a bounding box has been declared in the drawing, it is */
6987 /* centered on the page. Otherwise, the drawing itself is */
6988 /* centered on the page. If encapsulated, the bounding box */
6989 /* encompasses only the object itself. */
6990
6991 width = toplevelwidth(writepage, &origin.x);
6992 height = toplevelheight(writepage, &origin.y);
6993
6994 corner.x = origin.x + width;
6995 corner.y = origin.y + height;
6996
6997 if (xobjs.pagelist[mpage]->pmode & 1) { /* full page */
6998
6999 if (xobjs.pagelist[mpage]->orient == 90) {
7000 xmargin = (xobjs.pagelist[mpage]->pagesize.x -
7001 ((float)height * psscale)) / 2;
7002 ymargin = (xobjs.pagelist[mpage]->pagesize.y -
7003 ((float)width * psscale)) / 2;
7004 }
7005 else {
7006 xmargin = (xobjs.pagelist[mpage]->pagesize.x -
7007 ((float)width * psscale)) / 2;
7008 ymargin = (xobjs.pagelist[mpage]->pagesize.y -
7009 ((float)height * psscale)) / 2;
7010 }
7011 }
7012 else { /* encapsulated --- should have 1" border so that any */
7013 /* drawing passed directly to a printer will not clip */
7014 xmargin = xobjs.pagelist[mpage]->margins.x;
7015 ymargin = xobjs.pagelist[mpage]->margins.y;
7016 }
7017
7018 /* If a framebox is declared, then we adjust the page to be */
7019 /* centered on the framebox by translating through the */
7020 /* difference between the object center and the framebox */
7021 /* center. */
7022
7023 if ((framebox = checkforbbox(localdata)) != NULL) {
7024 int i, fcentx = 0, fcenty = 0;
7025
7026 for (i = 0; i < framebox->number; i++) {
7027 fcentx += framebox->points[i].x;
7028 fcenty += framebox->points[i].y;
7029 }
7030 fcentx /= framebox->number;
7031 fcenty /= framebox->number;
7032
7033 xmargin += psscale * (float)(origin.x + (width >> 1) - fcentx);
7034 ymargin += psscale * (float)(origin.y + (height >> 1) - fcenty);
7035 }
7036
7037 /* If the page label is just the root name of the file, or has been left */
7038 /* as "Page n" or "Page_n", just do the normal page numbering. Otherwise, */
7039 /* write out the page label explicitly. */
7040
7041 if ((rootptr == NULL) || (!strcmp(rootptr, localdata->name))
7042 || (strchr(localdata->name, ' ') != NULL)
7043 || (strstr(localdata->name, "Page_") != NULL))
7044 fprintf (ps, "%%%%Page: %d %d\n", page, page);
7045 else
7046 fprintf (ps, "%%%%Page: %s %d\n", localdata->name, page);
7047
7048 if (xobjs.pagelist[mpage]->orient == 90)
7049 fprintf (ps, "%%%%PageOrientation: Landscape\n");
7050 else
7051 fprintf (ps, "%%%%PageOrientation: Portrait\n");
7052
7053 if (xobjs.pagelist[mpage]->pmode & 1) { /* full page */
7054 fprintf(ps, "%%%%PageBoundingBox: 0 0 %d %d\n",
7055 xobjs.pagelist[mpage]->pagesize.x,
7056 xobjs.pagelist[mpage]->pagesize.y);
7057 }
7058
7059 /* Encapsulated files do not get a PageBoundingBox line, */
7060 /* unless the bounding box was explicitly drawn. */
7061
7062 else if (framebox != NULL) {
7063 fprintf(ps, "%%%%PageBoundingBox: %g %g %g %g\n",
7064 xmargin, ymargin,
7065 xmargin + psscale * (float)(width),
7066 ymargin + psscale * (float)(height));
7067 }
7068
7069 fprintf (ps, "/pgsave save def bop\n");
7070
7071 /* Top-page definitions */
7072 if (localdata->params != NULL) {
7073 printobjectparams(ps, localdata);
7074 fprintf(ps, "begin\n");
7075 }
7076
7077 if (localdata->symschem != NULL) {
7078 if (is_page(localdata->symschem) == -1)
7079 fprintf(ps, "%% %s is_symbol\n", localdata->symschem->name);
7080 else if (localdata->schemtype == SECONDARY)
7081 fprintf(ps, "%% %s is_primary\n", localdata->symschem->name);
7082 else
7083 Wprintf("Something is wrong. . . schematic \"%s\" is connected to"
7084 " schematic \"%s\" but is not declared secondary.\n",
7085 localdata->name, localdata->symschem->name);
7086 }
7087
7088 /* Extend bounding box around schematic pins */
7089 extendschembbox(xobjs.pagelist[mpage]->pageinst, &origin, &corner);
7090
7091 if (xobjs.pagelist[mpage]->drawingscale.x != 1
7092 || xobjs.pagelist[mpage]->drawingscale.y != 1)
7093 fprintf(ps, "%% %hd:%hd drawingscale\n", xobjs.pagelist[mpage]->drawingscale.x,
7094 xobjs.pagelist[mpage]->drawingscale.y);
7095
7096 if (xobjs.pagelist[mpage]->gridspace != 32
7097 || xobjs.pagelist[mpage]->snapspace != 16)
7098 fprintf(ps, "%% %4.2f %4.2f gridspace\n", xobjs.pagelist[mpage]->gridspace,
7099 xobjs.pagelist[mpage]->snapspace);
7100
7101 if (xobjs.pagelist[mpage]->background.name != (char *)NULL) {
7102 /* float iscale = (xobjs.pagelist[mpage]->coordstyle == CM) ? CMSCALE : INCHSCALE; (jdk) */
7103 if (xobjs.pagelist[mpage]->orient == 90)
7104 fprintf(ps, "%5.4f %d %d 90 psinsertion\n", psnorm,
7105 (int)(ymargin - xmargin),
7106 -((int)((float)(corner.y - origin.y) * psscale) +
7107 (int)(xmargin + ymargin)));
7108 else
7109 fprintf(ps, "%5.4f %d %d 0 psinsertion\n", psnorm,
7110 (int)(xmargin / psscale) - origin.x,
7111 (int)(ymargin / psscale) - origin.y);
7112 savebackground(ps, xobjs.pagelist[mpage]->background.name);
7113 fprintf(ps, "\nend_insert\n");
7114 }
7115
7116 if (xobjs.pagelist[mpage]->orient == 90)
7117 fprintf(ps, "90 rotate %d %d translate\n", (int)(ymargin - xmargin),
7118 -((int)((float)(corner.y - origin.y) * psscale) +
7119 (int)(xmargin + ymargin)));
7120
7121 fprintf(ps, "%5.4f ", psnorm);
7122 switch(xobjs.pagelist[mpage]->coordstyle) {
7123 case CM:
7124 fprintf(ps, "cmscale\n");
7125 break;
7126 default:
7127 fprintf(ps, "inchscale\n");
7128 break;
7129 }
7130
7131 /* Final scale and translation */
7132 fprintf(ps, "%5.4f setlinewidth %d %d translate\n\n",
7133 1.3 * xobjs.pagelist[mpage]->wirewidth,
7134 (int)(xmargin / psscale) - origin.x,
7135 (int)(ymargin / psscale) - origin.y);
7136
7137 /* Output all the elements in the page */
7138 printOneObject(ps, localdata, DEFAULTCOLOR);
7139
7140 /* Page trailer */
7141 if (localdata->params != NULL) fprintf(ps, "end ");
7142 fprintf(ps, "pgsave restore showpage\n");
7143 }
7144
7145 /*--------------------------------------------------------------*/
7146 /* Print objects referenced from a particular page. These get */
7147 /* bundled together at the beginning of the output file under */
7148 /* the DSC "Setup" section, so that the PostScript */
7149 /* interpreter knows that these definitions may be used by any */
7150 /* page. This prevents ghostscript from producing an error */
7151 /* when backing up in a multi-page document. */
7152 /*--------------------------------------------------------------*/
7153
7154 void printrefobjects(FILE *ps, objectptr localdata, objectptr **wrotelist,
7155 short *written)
7156 {
7157 genericptr *gptr;
7158
7159 /* If this page is a schematic, write out the definiton of any symbol */
7160 /* attached to it, because that symbol may not be used anywhere else. */
7161
7162 if (localdata->symschem && (localdata->schemtype == PRIMARY))
7163 printobjects(ps, localdata->symschem, wrotelist, written, DEFAULTCOLOR);
7164
7165 /* Search for all object definitions instantiated on the page and */
7166 /* write them to the output. */
7167
7168 for (gptr = localdata->plist; gptr < localdata->plist + localdata->parts; gptr++)
7169 if (IS_OBJINST(*gptr))
7170 printobjects(ps, TOOBJINST(gptr)->thisobject, wrotelist, written,
7171 DEFAULTCOLOR);
7172 }
7173
7174 /*----------------------------------------------------------------------*/
XCircuit is a program for drawing publishable-quality electrical circuit schematic diagrams and related figures, and produce circuit netlists through schematic capture.