![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pic1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / Jpic|
Return to pic1.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / Jpic |
1.1 root 1: #include <stdio.h>
2: #include "pic.h"
3: #include "y.tab.h"
4: #define dprintf if(dbg)printf
5:
6: #define PI 3.141592654
7: #define PI2 PI/2
8: #define SCALE 200 /* default scale: units/inch */
9: #define WID 150 /* default width for boxes and ellipses */
10: #define HT 100 /* default height and line length */
11:
12: /* But there's one of these in pic.h? -Bart
13: #define MAXOBJ 400
14: */
15: struct obj *objlist[MAXOBJ]; /* store the elements here */
16: int nobj = 0;
17:
18: struct attr attr[40]; /* attributes stored here as collected */
19: int nattr = 0; /* number of entries in attr_list */
20:
21: #define MAXTEXT 200
22: struct text text[MAXTEXT]; /* text strings stored here as collected */
23: int ntext = 0;
24: int ntext1 = 0; /* record ntext here on entry to each figure */
25:
26: #define SYMTAB 200
27: struct symtab symtab[SYMTAB];
28: int nsymtab = 0;
29:
30: coord curx = 0;
31: coord cury = 0;
32:
33: int hvmode = R_DIR; /* R => join left to right, D => top to bottom, etc. */
34:
35: #define MAXTYPE 12
36: int first[MAXTYPE]; /* indicates whether first of particular type */
37: /* has been seen within this picture */
38:
39: int codegen = 0; /* 1=>output for this picture; 0=>no output */
40:
41: struct obj *makenode();
42: char *malloc();
43:
44: float deltx = 6; /* max x value in output, for scaling */
45: float delty = 6; /* max y value in output, for scaling */
46: float scale = 0; /* implies simply scaling by this value; no crop or shift */
47: int dbg = 0;
48: extern FILE *yyin; /* input file pointer */
49: int lineno = 0;
50: char *filename = "-";
51: int synerr = 0;
52: char *cmdname;
53: int crop = 1; /* trim off exterior white space if non-zero */
54:
55: #define DEV202 1
56: #define DEVAPS 2
57: #define DEVCAT 3
58: #define DEV450 4
59:
60: /* You may want to change this if you don't have a 202... */
61:
62: int devtype = DEV202;
63: int res = 972; /* default is 202 */
64: int DX = 4; /* used only for old-style troff */
65: int DY = 4;
66:
67: /* mandatory values for graphic systems CAT: */
68: /*
69: int devtype = DEVCAT;
70: int res = 432;
71: int DX = 3;
72: int DY = 3;
73: */
74:
75: float hshift = 0; /* move this far left for text (in em's) */
76: float vshift = 0.2; /* this far down */
77:
78: coord sxmin; /* lower limit from s command */
79: coord symin;
80: coord sxmax = 4096; /* upper */
81: coord symax = 4096;
82:
83: coord xmin = 30000; /* min values found in actual data */
84: coord ymin = 30000;
85: coord xmax = -30000; /* max */
86: coord ymax = -30000;
87:
88: extern float atof();
89:
90: main(argc,argv)
91: char **argv;
92: {
93: int casel, c;
94:
95: cmdname = argv[0];
96: casel = 0;
97: while (argc > 1 && *argv[1] == '-') {
98: switch (c = argv[1][1]) {
99: case 'T':
100: if (strcmp(&argv[1][2], "aps") == 0) {
101: res = 720;
102: devtype = DEVAPS;
103: DX = DY = 1;
104: } else if (strcmp(&argv[1][2], "cat") == 0) {
105: res = 432;
106: devtype = DEVCAT;
107: DX = DY = 3;
108: } else if (strcmp(&argv[1][2], "450") == 0) {
109: res = 240;
110: devtype = DEV450;
111: } else {
112: res = atoi(&argv[1][2]);
113: }
114: break;
115: case 'c':
116: crop = 0;
117: break;
118: case 'l':
119: delty = atof(&argv[1][2]);
120: casel = 0;
121: break;
122: case 'w':
123: case 's':
124: if (argv[1][2] == 0) {
125: argv++;
126: argc--;
127: deltx = atof(&argv[1][0]);
128: } else
129: deltx = atof(&argv[1][2]);
130: if (c == 's')
131: scale = deltx;
132: break;
133: case 'd':
134: dbg = 1;
135: break;
136: }
137: argc--;
138: argv++;
139: }
140: if (!casel)
141: delty = deltx;
142: setdefaults();
143: if (argc <= 1) {
144: yyin = stdin;
145: getdata(yyin);
146: } else
147: while (argc-- > 1) {
148: if ((yyin = fopen(*++argv, "r")) == NULL) {
149: fprintf(stderr, "pic: can't open %s\n", *argv);
150: exit(1);
151: }
152: filename = *argv;
153: getdata(yyin);
154: fclose(yyin);
155: }
156: exit(0);
157: }
158:
159: setdefaults() /* set default sizes for variables like boxht */
160: {
161: static struct {
162: char *name;
163: int val;
164: } defaults[] ={
165: "lineht", HT,
166: "linewid", HT,
167: "moveht", HT,
168: "movewid", HT,
169: "dashwid", HT/10,
170: "boxht", HT,
171: "boxwid", WID,
172: "circlerad", HT/2,
173: "arcrad", HT/2,
174: "ellipseht", HT,
175: "ellipsewid", WID,
176: "arrowht", HT/5,
177: "arrowwid", HT/10,
178: "textht", HT,
179: "textwid", WID,
180: "scale", SCALE,
181: NULL, 0
182: };
183: int i;
184:
185: for (i = 0; defaults[i].name != NULL; i++)
186: makevar(defaults[i].name, VARNAME, defaults[i].val);
187: }
188:
189: getdata(fin)
190: register FILE *fin;
191: {
192: char buf[1000], buf1[50];
193: FILE *svyyin;
194: int svlineno;
195: char *svfilename, *p;
196:
197: lineno = 0;
198: while (fgets(buf, sizeof buf, fin) != NULL) {
199: lineno++;
200: if (*buf == '.' && *(buf+1) == 'P' && *(buf+2) == 'S') {
201: for (p = &buf[3]; *p == ' '; p++)
202: ;
203: if (*p++ == '<') {
204: svyyin = yyin;
205: svlineno = lineno;
206: svfilename = filename;
207: sscanf(p, "%s", buf1);
208: if ((yyin = fopen(buf1, "r")) == NULL) {
209: fprintf(stderr, "pic: can't open %s\n", buf1);
210: exit(1);
211: }
212: lineno = 0;
213: filename = p;
214: getdata(yyin);
215: fclose(yyin);
216: lineno = svlineno;
217: yyin = svyyin;
218: filename = svfilename;
219: continue;
220: }
221: reset();
222: yyparse();
223: if (buf[3] == ' ') /* assume next thing is width */
224: deltx = delty = atof(&buf[4]);
225: else { /* use scale to determine size */
226: int t;
227: t = xmax - xmin;
228: if (t == 0)
229: t = ymax - ymin;
230: deltx = delty = (float) t / (float)getvar(lookup("scale"));
231: }
232: dprintf("deltx = %.3f\n", deltx);
233: if (codegen && !synerr) {
234: openpl(&buf[3]); /* puts out .PS, with ht & wid stuck in */
235: print(); /* assumes \n at end */
236: closepl(); /* this does the .PE */
237: }
238: }
239: else
240: fputs(buf, stdout);
241: }
242: }
243:
244: print()
245: {
246: struct obj *p;
247: int i, j, m;
248: coord x0, y0, x1, y1, ox, oy, dx, dy;
249:
250: for (i = 0; i < nobj; i++) {
251: p = objlist[i];
252: ox = p->o_x;
253: oy = p->o_y;
254: x1 = p->o_val[0];
255: y1 = p->o_val[1];
256: m = p->o_mode;
257: switch (p->o_type) {
258: case TROFF:
259: troff(text[p->o_nt1].t_val);
260: break;
261: case BOX:
262: move(ox, oy);
263: dotext(p); /* if there are any text strings */
264: x0 = ox - (x1+1) / 2;
265: y0 = oy - (y1+1) / 2;
266: x1 = ox + x1 / 2;
267: y1 = oy + y1 / 2;
268: if (p->o_attr & INVIS)
269: ; /* nothing at all */
270: else if (p->o_dotdash == 0)
271: box(x0, y0, x1, y1);
272: else
273: dotbox(x0, y0, x1, y1, p->o_dotdash, p->o_ddval);
274: if (ishor(m))
275: move(isright(m) ? x1 : x0, oy); /* right side */
276: else
277: move(ox, isdown(m) ? y0 : y1); /* bottom */
278: break;
279: case CIRCLE:
280: move(ox, oy);
281: dotext(p);
282: if ((p->o_attr & INVIS) == 0)
283: circle(ox, oy, x1);
284: if (ishor(m))
285: move(ox + isright(m) ? x1 : -x1, oy);
286: else
287: move(ox, oy + isup(m) ? x1 : -x1);
288: break;
289: case ELLIPSE:
290: move(ox, oy);
291: dotext(p);
292: if ((p->o_attr & INVIS) == 0)
293: ellipse(ox, oy, x1, y1);
294: if (ishor(m))
295: move(ox + isright(m) ? x1 : -x1, oy);
296: else
297: move(ox, oy - isdown(m) ? y1 : -y1);
298: break;
299: case ARC:
300: move(ox, oy);
301: dotext(p);
302: if (p->o_attr & HEAD1)
303: arrow(x1 - (y1 - oy), y1 + (x1 - ox),
304: x1, y1, p->o_val[4], p->o_val[5]);
305: if (p->o_attr & INVIS)
306: /* probably wrong when it's cw */
307: move(x1, y1);
308: else
309: arc(ox, oy, x1, y1, p->o_val[2], p->o_val[3]);
310: if (p->o_attr & HEAD2)
311: arrow(p->o_val[2] + p->o_val[3] - oy, p->o_val[3] - (p->o_val[2] - ox),
312: p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5]);
313: if (p->o_attr & CW_ARC)
314: move(x1, y1); /* because drawn backwards */
315: break;
316: case LINE:
317: case ARROW:
318: case SPLINE:
319: move((ox + x1)/2, (oy + y1)/2); /* center */
320: dotext(p);
321: if (p->o_attr & HEAD1)
322: arrow(ox + p->o_val[5], oy + p->o_val[6], ox, oy, p->o_val[2], p->o_val[3]);
323: if (p->o_attr & INVIS)
324: move(x1, y1);
325: else if (p->o_type == SPLINE)
326: spline(ox, oy, p->o_val[4], &p->o_val[5]);
327: else {
328: int i, j, ndx, ndy;
329: dx = ox;
330: dy = oy;
331: for (i=0, j=5; i < p->o_val[4]; i++, j += 2) {
332: ndx = dx + p->o_val[j];
333: ndy = dy + p->o_val[j+1];
334: if (p->o_dotdash == 0)
335: line(dx, dy, ndx, ndy);
336: else
337: dotline(dx, dy, ndx, ndy, p->o_dotdash, p->o_ddval);
338: dx = ndx;
339: dy = ndy;
340: }
341: }
342: if (p->o_attr & HEAD2) {
343: int i, j;
344: dx = ox;
345: dy = oy;
346: for (i = 0, j = 5; i < p->o_val[4] - 1; i++, j += 2) {
347: dx += p->o_val[j];
348: dy += p->o_val[j+1];
349: }
350: arrow(dx, dy, x1, y1, p->o_val[2], p->o_val[3]);
351: }
352: break;
353: case MOVE:
354: move(ox, oy);
355: dotext(p);
356: break;
357: case TEXT:
358: move(ox, oy);
359: label(x1, y1, 0);
360: free(x1);
361: break;
362: }
363: }
364: }
365:
366: dotline(x0, y0, x1, y1, ddtype, ddval) /* dotted line */
367: coord x0, y0, x1, y1;
368: int ddtype;
369: int ddval;
370: {
371: static int prevval = SCALE/20; /* 20 per inch by default */
372: int i, numdots;
373: double a, b, sqrt(), dx, dy;
374:
375: if (ddval == 0)
376: ddval = prevval;
377: prevval = ddval;
378: /* don't save dot/dash value */
379: dx = x1 - x0;
380: dy = y1 - y0;
381: if (ddtype == DOT) {
382: numdots = sqrt(dx*dx + dy*dy) / prevval + 0.5;
383: for (i = 0; i <= numdots; i++) {
384: a = (float) i / (float) numdots;
385: move(x0 + (int)(a * dx), y0 + (int)(a * dy));
386: dot();
387: }
388: } else if (ddtype == DASH) {
389: double d, dashsize, spacesize;
390: d = sqrt(dx*dx + dy*dy) + 0.5;
391: if (d <= 2 * prevval) {
392: line(x0, y0, x1, y1);
393: return;
394: }
395: numdots = d / (2 * prevval - 1) + 1; /* ceiling */
396: dashsize = prevval;
397: spacesize = (d - numdots * dashsize) / (numdots - 1);
398: for (i = 0; i < numdots-1; i++) {
399: a = i * (dashsize + spacesize) / d;
400: b = a + dashsize / d;
401: line(x0 + (int)(a*dx), y0 + (int)(a*dy), x0 + (int)(b*dx), y0 + (int)(b*dy));
402: a = b;
403: b = a + spacesize / d;
404: move(x0 + (int)(a*dx), y0 + (int)(a*dy));
405: }
406: line(x0 + (int)(b * dx), y0 + (int)(b * dy), x1, y1);
407: }
408: prevval = SCALE/20;
409: }
410:
411: dotbox(x0, y0, x1, y1, ddtype, ddval) /* dotted or dashed box */
412: coord x0, y0, x1, y1;
413: int ddtype;
414: int ddval;
415: {
416: dotline(x0, y0, x1, y0, ddtype, ddval);
417: dotline(x1, y0, x1, y1, ddtype, ddval);
418: dotline(x1, y1, x0, y1, ddtype, ddval);
419: dotline(x0, y1, x0, y0, ddtype, ddval);
420: }
421:
422: dotext(p) /* print text strings of p in proper vertical spacing */
423: struct obj *p;
424: {
425: int i, nhalf;
426:
427: nhalf = p->o_nt2 - p->o_nt1 - 1;
428: for (i = p->o_nt1; i < p->o_nt2; i++) {
429: label(text[i].t_val, text[i].t_type, nhalf);
430: nhalf -= 2;
431: }
432: }
433:
434: reset()
435: {
436: int i;
437:
438: for (i = 0; i < nobj; i++)
439: free(objlist[i]);
440: nobj = 0;
441: nattr = 0;
442: for (i = 0; i < ntext; i++)
443: free(text[i].t_val);
444: ntext = ntext1 = 0;
445: for (i = 0; i < MAXTYPE; i++)
446: first[i] = 0;
447: codegen = synerr = 0;
448: curx = cury = 0;
449: hvmode = R_DIR;
450: sxmin = symin = 0;
451: sxmax = symax = 4096;
452: xmin = ymin = 30000;
453: xmax = ymax = -30000;
454: }
455:
456: coord xstack[20]; /* store curx here for pushdown {...} */
457: coord ystack[20];
458: int hvstack[20];
459: int nstack = 0;
460:
461: push()
462: {
463: xstack[nstack] = curx;
464: ystack[nstack] = cury;
465: hvstack[nstack] = hvmode;
466: nstack++;
467: }
468:
469: pop()
470: {
471: struct obj *p;
472:
473: nstack--;
474: curx = xstack[nstack];
475: cury = ystack[nstack];
476: hvmode = hvstack[nstack];
477: p = makenode(MOVE, 0);
478: dprintf("M %d %d\n", curx, cury);
479: }
480:
481: setvar(n, v, t) /* store v in variable in table slot n */
482: {
483: symtab[n].s_val = v;
484: symtab[n].s_type = t;
485: }
486:
487: getvar(n) /* return value of variable in slot n */
488: {
489: return(symtab[n].s_val);
490: }
491:
492: setdir(n) /* set direction from n */
493: int n;
494: {
495: switch (n) {
496: case UP: hvmode = U_DIR; break;
497: case DOWN: hvmode = D_DIR; break;
498: case LEFT: hvmode = L_DIR; break;
499: case RIGHT: hvmode = R_DIR; break;
500: }
501: return(hvmode);
502: }
503:
504: coord getcomp(p, t) /* return component of a position */
505: struct obj *p;
506: int t;
507: {
508: switch (t) {
509: case DOTX:
510: return(p->o_x);
511: case DOTY:
512: return(p->o_y);
513: case DOTWID:
514: switch (p->o_type) {
515: case BOX:
516: return(p->o_val[0]);
517: case CIRCLE:
518: case ELLIPSE:
519: return(2 * p->o_val[0]);
520: case LINE:
521: case ARROW:
522: return(p->o_val[0] - p->o_x);
523: }
524: case DOTHT:
525: switch (p->o_type) {
526: case BOX:
527: return(p->o_val[1]);
528: case CIRCLE:
529: case ELLIPSE:
530: return(2 * p->o_val[1]);
531: case LINE:
532: case ARROW:
533: return(p->o_val[1] - p->o_y);
534: }
535: case DOTRAD:
536: switch (p->o_type) {
537: case CIRCLE:
538: case ELLIPSE:
539: return(p->o_val[0]);
540: }
541: }
542: }
543:
544:
545: makeattr(type, val) /* add attribute type and val */
546: int type;
547: int val; /* typing probably wrong */
548: {
549: if (type == 0 && val == 0) { /* clear table for next stat */
550: nattr = 0;
551: return;
552: }
553: dprintf("attr %d: %d %d\n", nattr, type, val);
554: attr[nattr].a_type = type;
555: attr[nattr].a_val = val;
556: nattr++;
557: }
558:
559: troffgen(s) /* save away a string of troff commands */
560: char *s;
561: {
562: savetext(CENTER, s); /* use the existing text mechanism */
563: makenode(TROFF, 0);
564: }
565:
566: printexpr(n) /* print expression for debugging */
567: int n;
568: {
569: dprintf("%d\n", n);
570: }
571:
572: struct obj *boxgen(type)
573: {
574: static int prevh = HT;
575: static int prevw = WID; /* golden mean, sort of */
576: int i, invis, at, ddtype, ddval;
577: int with, xwith, ywith;
578: int h, w;
579: coord x0, y0, x1, y1;
580: struct obj *p, *ppos;
581:
582: /* EXPENSIVE! */
583: h = getvar(lookup("boxht"));
584: w = getvar(lookup("boxwid"));
585: invis = at = 0;
586: with = xwith = ywith = 0;
587: ddtype = ddval = 0;
588: for (i = 0; i < nattr; i++) {
589: switch (attr[i].a_type) {
590: case HEIGHT:
591: h = attr[i].a_val;
592: break;
593: case WIDTH:
594: w = attr[i].a_val;
595: break;
596: case SAME:
597: h = prevh;
598: w = prevw;
599: break;
600: case WITH:
601: with = attr[i].a_val; /* corner */
602: break;
603: case AT:
604: ppos = (struct obj *) attr[i].a_val;
605: curx = ppos->o_x;
606: cury = ppos->o_y;
607: at++;
608: break;
609: case INVIS:
610: invis = INVIS;
611: break;
612: case DOT:
613: case DASH:
614: ddtype = attr[i].a_type;
615: ddval = attr[i].a_val;
616: if (ddval == 0)
617: ddval = getvar(lookup("dashwid"));
618: break;
619: case LJUST: case RJUST: case CENTER: case SPREAD: case FILL: case ABOVE: case BELOW:
620: savetext(attr[i].a_type, attr[i].a_val);
621: break;
622: }
623: }
624: if (with) {
625: switch (with) {
626: case NORTH: ywith = -((h+1) / 2); break;
627: case SOUTH: ywith = h / 2; break;
628: case EAST: xwith = -((w+1) / 2); break;
629: case WEST: xwith = w / 2; break;
630: case NE: xwith = -((w+1) / 2); ywith = -((h+1) / 2); break;
631: case SE: xwith = -((w+1) / 2); ywith = h / 2; break;
632: case NW: xwith = w / 2; ywith = -((h+1) / 2); break;
633: case SW: xwith = w / 2; ywith = h / 2; break;
634: }
635: curx += xwith;
636: cury += ywith;
637: }
638: if (!at) {
639: if (isright(hvmode))
640: curx += (w+1) / 2;
641: else if (isleft(hvmode))
642: curx -= w / 2;
643: else if (isup(hvmode))
644: cury += (h+1) / 2;
645: else
646: cury -= h / 2;
647: }
648: x0 = curx - w / 2;
649: y0 = cury - h / 2;
650: x1 = curx + (w+1) / 2;
651: y1 = cury + (h+1) / 2;
652: extreme(x0, y0);
653: extreme(x1, y1);
654: p = makenode(BOX, 2);
655: p->o_val[0] = w;
656: p->o_val[1] = h;
657: p->o_dotdash = ddtype;
658: p->o_ddval = ddval;
659: p->o_attr = invis;
660: dprintf("B %d %d %d %d at %d %d, h=%d, w=%d\n", x0, y0, x1, y1, curx, cury, h, w);
661: if (isright(hvmode))
662: curx = x1;
663: else if (isleft(hvmode))
664: curx = x0;
665: else if (isup(hvmode))
666: cury = y1;
667: else
668: cury = y0;
669: prevh = h;
670: prevw = w;
671: return(p);
672: }
673:
674: savetext(t, s) /* record text elements for current object */
675: int t;
676: char *s;
677: {
678: switch (t) {
679: case CENTER: t = 'C'; break;
680: case LJUST: t = 'L'; break;
681: case RJUST: t = 'R'; break;
682: case SPREAD: t = 'S'; break;
683: case FILL: t = 'F'; break;
684: case ABOVE: t = 'A'; break;
685: case BELOW: t = 'B'; break;
686: }
687: if (ntext >= MAXTEXT) {
688: fprintf(stderr, "too many text strings (%d)\n", ntext);
689: exit(1);
690: }
691: text[ntext].t_type = t;
692: text[ntext].t_val = s;
693: dprintf("saving %c text %s at %d\n", t, s, ntext);
694: ntext++;
695: }
696:
697: struct obj *circgen(type)
698: {
699: static int rad[2] = { HT/2, WID/2 };
700: static int rad2[2] = { HT/2, HT/2 };
701: static coord x0, y0, x1, y1, x2, y2;
702: int i, at, t, invis;
703: int with, xwith, ywith;
704: int r, r2;
705: struct obj *p, *ppos;
706:
707: at = invis = 0;
708: with = xwith = ywith = 0;
709: t = (type == CIRCLE) ? 0 : 1;
710: if (type == CIRCLE)
711: r = r2 = getvar(lookup("circlerad"));
712: else if (type == ELLIPSE) {
713: r = getvar(lookup("ellipsewid")) / 2;
714: r2 = getvar(lookup("ellipseht")) / 2;
715: }
716: for (i = 0; i < nattr; i++)
717: switch (attr[i].a_type) {
718: case LJUST: case RJUST: case CENTER: case SPREAD: case FILL: case ABOVE: case BELOW:
719: savetext(attr[i].a_type, attr[i].a_val);
720: break;
721: case RADIUS:
722: r = attr[i].a_val;
723: break;
724: case DIAMETER:
725: case WIDTH:
726: r = (attr[i].a_val + 1) / 2;
727: break;
728: case HEIGHT:
729: r2 = (attr[i].a_val + 1) / 2;
730: break;
731: case SAME:
732: r = rad[t];
733: r2 = rad2[t];
734: break;
735: case WITH:
736: with = attr[i].a_val;
737: break;
738: case AT:
739: ppos = (struct obj *) attr[i].a_val;
740: curx = ppos->o_x;
741: cury = ppos->o_y;
742: at++;
743: break;
744: case INVIS:
745: invis = INVIS;
746: break;
747: }
748: if (type == CIRCLE)
749: r2 = r; /* probably superfluous */
750: if (with) {
751: switch (with) {
752: case NORTH: ywith = -r2; break;
753: case SOUTH: ywith = r2; break;
754: case EAST: xwith = -r; break;
755: case WEST: xwith = r; break;
756: case NE: xwith = -r * 0.707; ywith = -r2 * 0.707; break;
757: case SE: xwith = -r * 0.707; ywith = r2 * 0.707; break;
758: case NW: xwith = r * 0.707; ywith = -r2 * 0.707; break;
759: case SW: xwith = r * 0.707; ywith = r2 * 0.707; break;
760: }
761: curx += xwith;
762: cury += ywith;
763: }
764: if (!at) {
765: if (isright(hvmode))
766: curx += r;
767: else if (isleft(hvmode))
768: curx -= r;
769: else if (isup(hvmode))
770: cury += r2;
771: else
772: cury -= r2;
773: }
774: p = makenode(type, 2);
775: p->o_val[0] = rad[t] = r;
776: p->o_val[1] = rad2[t] = r2;
777: if (r <= 0 || r2 <= 0) {
778: yyerror("%s has invalid radius %d\n", (type==CIRCLE) ? "circle" : "ellipse", r<r2 ? r : r2);
779: }
780: p->o_attr = invis;
781: extreme(curx+r, cury+r2);
782: extreme(curx-r, cury-r2);
783: if (type == CIRCLE)
784: dprintf("C %d %d %d\n", curx, cury, r);
785: if (type == ELLIPSE)
786: dprintf("E %d %d %d %d\n", curx, cury, r, r2);
787: if (isright(hvmode))
788: curx += r;
789: else if (isleft(hvmode))
790: curx -= r;
791: else if (isup(hvmode))
792: cury += r2;
793: else
794: cury -= r2;
795: return(p);
796: }
797:
798: struct obj *arcgen(type) /* handles circular and (eventually) elliptical arcs */
799: {
800: static int prevw = HT/10;
801: static int prevh = HT/5;
802: static int prevrad = HT/2;
803: static int dtox[2][4] ={ 1, -1, -1, 1, 1, 1, -1, -1 };
804: static int dtoy[2][4] ={ 1, 1, -1, -1, -1, 1, 1, -1 };
805: static int dctrx[2][4] ={ 0, -1, 0, 1, 0, 1, 0, -1 };
806: static int dctry[2][4] ={ 1, 0, -1, 0, -1, 0, 1, 0 };
807: static int nexthv[2][4] ={ U_DIR, L_DIR, D_DIR, R_DIR, D_DIR, R_DIR, U_DIR, L_DIR };
808: double sqrt(), atan2(), sin(), cos();
809: float dx2, dy2, ht, phi, r, d;
810: int i, head, to, at, cw, invis;
811: struct obj *p, *ppos;
812: coord fromx, fromy, tox, toy;
813:
814: prevrad = getvar(lookup("arcrad"));
815: prevh = getvar(lookup("arrowht"));
816: prevw = getvar(lookup("arrowwid"));
817: fromx = curx;
818: fromy = cury;
819: head = to = at = cw = invis = 0;
820: for (i = 0; i < nattr; i++) {
821: switch (attr[i].a_type) {
822: case LJUST: case RJUST: case CENTER: case SPREAD: case FILL: case ABOVE: case BELOW:
823: savetext(attr[i].a_type, attr[i].a_val);
824: break;
825: case HEAD:
826: head += attr[i].a_val;
827: break;
828: case INVIS:
829: invis = INVIS;
830: break;
831: case HEIGHT: /* length of arrowhead */
832: prevh = attr[i].a_val;
833: break;
834: case WIDTH: /* width of arrowhead */
835: prevw = attr[i].a_val;
836: break;
837: case RADIUS:
838: prevrad = attr[i].a_val;
839: break;
840: case DIAMETER:
841: prevrad = attr[i].a_val / 2;
842: break;
843: case CW:
844: cw = 1;
845: break;
846: case FROM: /* start point of arc */
847: ppos = (struct obj *) attr[i].a_val;
848: fromx = ppos->o_x;
849: fromy = ppos->o_y;
850: break;
851: case TO: /* end point of arc */
852: ppos = (struct obj *) attr[i].a_val;
853: tox = ppos->o_x;
854: toy = ppos->o_y;
855: to++;
856: break;
857: case AT: /* center of arc */
858: ppos = (struct obj *) attr[i].a_val;
859: curx = ppos->o_x;
860: cury = ppos->o_y;
861: at = 1;
862: break;
863: case UP:
864: hvmode = U_DIR;
865: break;
866: case DOWN:
867: hvmode = D_DIR;
868: break;
869: case RIGHT:
870: hvmode = R_DIR;
871: break;
872: case LEFT:
873: hvmode = L_DIR;
874: break;
875: }
876: }
877: if (!at && !to) { /* the defaults are mostly OK */
878: curx = fromx + prevrad * dctrx[cw][hvmode];
879: cury = fromy + prevrad * dctry[cw][hvmode];
880: tox = fromx + prevrad * dtox[cw][hvmode];
881: toy = fromy + prevrad * dtoy[cw][hvmode];
882: hvmode = nexthv[cw][hvmode];
883: }
884: else if (!at) {
885: dx2 = (float)(tox - fromx) / 2;
886: dy2 = (float)(toy - fromy) / 2;
887: phi = atan2(dy2, dx2) + (cw ? -PI2 : PI2);
888: for (r=prevrad; (d = r*r - (dx2*dx2+dy2*dy2)) <= 0.0; r *= 2)
889: ; /* this kludge gets around too-small radii */
890: ht = sqrt(d);
891: curx = fromx + dx2 + ht * cos(phi) + 0.5;
892: cury = fromy + dy2 + ht * sin(phi) + 0.5;
893: dprintf("dx2,dy2=%g,%g, phi=%g, r,ht=%g,%g\n",
894: dx2, dy2, phi, r, ht);
895: }
896: else if (at && !to) { /* do we have all the cases??? */
897: tox = fromx + prevrad * dtox[cw][hvmode];
898: toy = fromy + prevrad * dtoy[cw][hvmode];
899: hvmode = nexthv[cw][hvmode];
900: }
901: if (cw) { /* interchange roles of from-to and heads */
902: coord temp;
903: temp = fromx; fromx = tox; tox = temp;
904: temp = fromy; fromy = toy; toy = temp;
905: if (head == HEAD1)
906: head = HEAD2;
907: else if (head == HEAD2)
908: head = HEAD1;
909: }
910: p = makenode(type, 6);
911: /* these are wrong in general */
912: extreme(fromx, fromy);
913: extreme(tox, toy);
914: p->o_val[0] = fromx;
915: p->o_val[1] = fromy;
916: p->o_val[2] = tox;
917: p->o_val[3] = toy;
918: if (cw) {
919: curx = fromx;
920: cury = fromy;
921: } else {
922: curx = tox;
923: cury = toy;
924: }
925: p->o_val[4] = prevw;
926: p->o_val[5] = prevh;
927: p->o_attr = head | (cw ? CW_ARC : 0) | invis;
928: dprintf("arc at %d %d from %d %d to %d %d head %d %d\n",
929: p->o_x, p->o_y,
930: p->o_val[0], p->o_val[1], p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5]);
931: return(p);
932: }
933:
934: struct obj *linegen(type)
935: {
936: static int prevdx = HT;
937: static int prevdy = 0;
938: static int prevw = HT/10;
939: static int prevh = HT/5;
940: int i, j, some, head, ddtype, ddval, invis;
941: int chop, chop1, chop2, x0, y0, x1, y1;
942: double sin(), cos(), atan2(), theta;
943: int defx, defy;
944: struct obj *p, *ppos;
945: static int xtab[] = { 1, 0, -1, 0 }; /* R=0, U=1, L=2, D=3 */
946: static int ytab[] = { 0, 1, 0, -1 };
947: int ndxy, dx[50], dy[50];
948: coord nx, ny;
949:
950: nx = curx;
951: ny = cury;
952: defx = getvar(lookup("linewid"));
953: defy = getvar(lookup("lineht"));
954: prevh = getvar(lookup("arrowht"));
955: prevw = getvar(lookup("arrowwid"));
956: dx[0] = dy[0] = ndxy = some = head = invis = 0;
957: chop = chop1 = chop2 = 0;
958: ddtype = ddval = 0;
959: for (i = 0; i < nattr; i++) {
960: switch (attr[i].a_type) {
961: case LJUST: case RJUST: case CENTER: case SPREAD: case FILL: case ABOVE: case BELOW:
962: savetext(attr[i].a_type, attr[i].a_val);
963: break;
964: case HEAD:
965: head += attr[i].a_val;
966: break;
967: case INVIS:
968: invis = INVIS;
969: break;
970: case CHOP:
971: if (chop++ == 0)
972: chop1 = chop2 = attr[i].a_val;
973: else
974: chop2 = attr[i].a_val;
975: break;
976: case DOT:
977: case DASH:
978: ddtype = attr[i].a_type;
979: ddval = attr[i].a_val;
980: if (ddval == 0)
981: ddval = getvar(lookup("dashwid"));
982: break;
983: case SAME:
984: dx[ndxy] = prevdx;
985: dy[ndxy] = prevdy;
986: some++;
987: break;
988: case LEFT:
989: dx[ndxy] -= (attr[i].a_val==0) ? defx : attr[i].a_val;
990: some++;
991: hvmode = L_DIR;
992: break;
993: case RIGHT:
994: dx[ndxy] += (attr[i].a_val==0) ? defx : attr[i].a_val;
995: some++;
996: hvmode = R_DIR;
997: break;
998: case UP:
999: dy[ndxy] += (attr[i].a_val==0) ? defy : attr[i].a_val;
1000: some++;
1001: hvmode = U_DIR;
1002: break;
1003: case DOWN:
1004: dy[ndxy] -= (attr[i].a_val==0) ? defy : attr[i].a_val;
1005: some++;
1006: hvmode = D_DIR;
1007: break;
1008: case HEIGHT: /* length of arrowhead */
1009: prevh = attr[i].a_val;
1010: break;
1011: case WIDTH: /* width of arrowhead */
1012: prevw = attr[i].a_val;
1013: break;
1014: case TO:
1015: if (some) {
1016: nx += dx[ndxy];
1017: ny += dy[ndxy];
1018: ndxy++;
1019: dx[ndxy] = dy[ndxy] = some = 0;
1020: }
1021: ppos = (struct obj *) attr[i].a_val;
1022: dx[ndxy] = ppos->o_x - nx;
1023: dy[ndxy] = ppos->o_y - ny;
1024: some++;
1025: break;
1026: case BY:
1027: ppos = (struct obj *) attr[i].a_val;
1028: dx[ndxy] = ppos->o_x;
1029: dy[ndxy] = ppos->o_y;
1030: some++;
1031: break;
1032: case THEN: /* turn off any previous accumulation */
1033: if (some) {
1034: nx += dx[ndxy];
1035: ny += dy[ndxy];
1036: ndxy++;
1037: dx[ndxy] = dy[ndxy] = some = 0;
1038: }
1039: break;
1040: case FROM:
1041: case AT:
1042: ppos = (struct obj *) attr[i].a_val;
1043: nx = curx = ppos->o_x;
1044: ny = cury = ppos->o_y;
1045: break;
1046: }
1047: }
1048: if (some) {
1049: nx += dx[ndxy];
1050: ny += dy[ndxy];
1051: ndxy++;
1052: defx = dx[ndxy-1];
1053: defy = dy[ndxy-1];
1054: } else {
1055: defx *= xtab[hvmode];
1056: defy *= ytab[hvmode];
1057: dx[ndxy] = defx;
1058: dy[ndxy] = defy;
1059: ndxy++;
1060: nx += defx;
1061: ny += defy;
1062: }
1063: prevdx = defx;
1064: prevdy = defy;
1065: if (chop) {
1066: if (chop == 1 && chop1 == 0) /* just said "chop", so use default */
1067: chop1 = chop2 = getvar(lookup("circlerad"));
1068: theta = atan2((float) defy, (float) defx);
1069: x0 = chop1 * cos(theta);
1070: y0 = chop1 * sin(theta);
1071: curx += x0;
1072: cury += y0;
1073: x1 = chop2 * cos(theta);
1074: y1 = chop2 * sin(theta);
1075: nx -= x1;
1076: ny -= y1;
1077: dx[0] -= x0;
1078: dy[0] -= y0;
1079: dx[ndxy-1] -= x1;
1080: dy[ndxy-1] -= y1;
1081: if(dbg)printf("chopping %d %d %d %d; cur=%d,%d end=%d,%d\n",
1082: x0, y0, x1, y1, curx, cury, nx, ny);
1083: }
1084: p = makenode(type, 5 + 2 * ndxy);
1085: curx = p->o_val[0] = nx;
1086: cury = p->o_val[1] = ny;
1087: if (head || type == ARROW) {
1088: p->o_val[2] = prevw;
1089: p->o_val[3] = prevh;
1090: if (head == 0)
1091: head = HEAD2; /* default arrow head */
1092: }
1093: p->o_attr = head | invis;
1094: p->o_val[4] = ndxy;
1095: nx = p->o_x;
1096: ny = p->o_y;
1097: for (i = 0, j = 5; i < ndxy; i++, j += 2) {
1098: p->o_val[j] = dx[i];
1099: p->o_val[j+1] = dy[i];
1100: extreme(nx += dx[i], ny += dy[i]);
1101: }
1102: p->o_dotdash = ddtype;
1103: p->o_ddval = ddval;
1104: if (dbg) {
1105: printf("S or L from %d %d to %d %d with %d elements:\n", p->o_x, p->o_y, curx, cury, ndxy);
1106: for (i = 0, j = 5; i < ndxy; i++, j += 2)
1107: printf("%d %d\n", p->o_val[j], p->o_val[j+1]);
1108: }
1109: extreme(p->o_x, p->o_y);
1110: extreme(curx, cury);
1111: return(p);
1112: }
1113:
1114: struct obj *splinegen(type)
1115: {
1116: linegen(type);
1117: }
1118:
1119: struct obj *movegen(type)
1120: {
1121: static int prevdx, prevdy;
1122: int i, dx, dy, some;
1123: int defx, defy;
1124: struct obj *p;
1125: struct obj *ppos;
1126: static int xtab[] = { 1, 0, -1, 0 }; /* R=0, U=1, L=2, D=3 */
1127: static int ytab[] = { 0, 1, 0, -1 };
1128:
1129: defx = getvar(lookup("movewid"));
1130: defy = getvar(lookup("moveht"));
1131: dx = dy = some = 0;
1132: for (i = 0; i < nattr; i++) {
1133: switch (attr[i].a_type) {
1134: case LJUST: case RJUST: case CENTER: case SPREAD: case FILL: case ABOVE: case BELOW:
1135: savetext(attr[i].a_type, attr[i].a_val);
1136: break;
1137: case SAME:
1138: dx = prevdx;
1139: dy = prevdy;
1140: some++;
1141: break;
1142: case LEFT:
1143: dx -= (attr[i].a_val==0) ? defx : attr[i].a_val;
1144: some++;
1145: hvmode = L_DIR;
1146: break;
1147: case RIGHT:
1148: dx += (attr[i].a_val==0) ? defx : attr[i].a_val;
1149: some++;
1150: hvmode = R_DIR;
1151: break;
1152: case UP:
1153: dy += (attr[i].a_val==0) ? defy : attr[i].a_val;
1154: some++;
1155: hvmode = U_DIR;
1156: break;
1157: case DOWN:
1158: dy -= (attr[i].a_val==0) ? defy : attr[i].a_val;
1159: some++;
1160: hvmode = D_DIR;
1161: break;
1162: case TO:
1163: ppos = (struct obj *) attr[i].a_val;
1164: dx = ppos->o_x - curx;
1165: dy = ppos->o_y - cury;
1166: some++;
1167: break;
1168: case BY:
1169: ppos = (struct obj *) attr[i].a_val;
1170: dx = ppos->o_x;
1171: dy = ppos->o_y;
1172: some++;
1173: break;
1174: case FROM:
1175: case AT:
1176: ppos = (struct obj *) attr[i].a_val;
1177: curx = ppos->o_x;
1178: cury = ppos->o_y;
1179: break;
1180: }
1181: }
1182: if (some) {
1183: defx = dx;
1184: defy = dy;
1185: } else {
1186: defx *= xtab[hvmode];
1187: defy *= ytab[hvmode];
1188: }
1189: prevdx = defx;
1190: prevdy = defy;
1191: extreme(curx, cury);
1192: curx += defx;
1193: cury += defy;
1194: extreme(curx, cury);
1195: p = makenode(MOVE, 0);
1196: dprintf("M %d %d\n", curx, cury);
1197: return(p);
1198: }
1199:
1200: struct obj *textgen(s, garb)
1201: {
1202: static int prevdx, prevdy, prevrad = 10;
1203: int i, dx, dy, some, type;
1204: struct obj *p, *ppos;
1205:
1206: type = 'C';
1207: some = dx = dy = 0;
1208: for (i = 0; i < nattr; i++)
1209: switch (attr[i].a_type) {
1210: case LEFT:
1211: dx -= attr[i].a_val;
1212: some++;
1213: break;
1214: case RIGHT:
1215: dx += attr[i].a_val;
1216: some++;
1217: break;
1218: case UP:
1219: dy += attr[i].a_val;
1220: some++;
1221: break;
1222: case DOWN:
1223: dy -= attr[i].a_val;
1224: some++;
1225: break;
1226: case AT:
1227: ppos = (struct obj *) attr[i].a_val;
1228: curx = ppos->o_x;
1229: cury = ppos->o_y;
1230: break;
1231: case LJUST:
1232: type = 'L';
1233: break;
1234: case RJUST:
1235: type = 'R';
1236: break;
1237: case SPREAD:
1238: type = 'S';
1239: break;
1240: case FILL:
1241: type = 'F';
1242: break;
1243: case ABOVE:
1244: type = 'A';
1245: break;
1246: case BELOW:
1247: type = 'B';
1248: break;
1249: }
1250: dprintf("T %c %s\n", type, s);
1251: if (some) {
1252: prevdx = dx;
1253: prevdy = dy;
1254: } else {
1255: dx = prevdx;
1256: dy = prevdy;
1257: }
1258: extreme(curx, cury);
1259: curx += dx;
1260: cury += dy;
1261: extreme(curx, cury); /* wrong */
1262: p = makenode(TEXT, 2);
1263: p->o_val[0] = s;
1264: p->o_val[1] = type;
1265: return(p);
1266: }
1267:
1268: char *tostring(s)
1269: register char *s;
1270: {
1271: register char *p;
1272:
1273: p = malloc(strlen(s)+1);
1274: if (p == NULL) {
1275: fprintf(stderr, "pic: out of space in tostring on %s", s);
1276: exit(1);
1277: }
1278: strcpy(p, s);
1279: return(p);
1280: }
1281:
1282: makevar(s, t, v) /* make variable named s in table */
1283: char *s;
1284: int t;
1285: int v; /* maybe wrong later */
1286: {
1287: int i;
1288:
1289: for (i = 0; i < nsymtab; i++)
1290: if (strcmp(s, symtab[i].s_name) == 0)
1291: return(i);
1292: if (nsymtab >= SYMTAB)
1293: yyerror("symbol table overflow (%d)", SYMTAB);
1294: symtab[nsymtab].s_name = tostring(s);
1295: symtab[nsymtab].s_type = t;
1296: symtab[nsymtab].s_val = v;
1297: return(nsymtab++);
1298: }
1299:
1300: lookup(s) /* find s in symtab */
1301: char *s;
1302: {
1303: int i;
1304:
1305: for (i = 0; i < nsymtab; i++)
1306: if (strcmp(s, symtab[i].s_name) == 0)
1307: return(i);
1308: return(-1);
1309: }
1310:
1311: struct obj *makepos(x, y) /* make a position cell */
1312: coord x;
1313: coord y;
1314: {
1315: struct obj *p;
1316:
1317: p = makenode(PLACE, 0);
1318: p->o_x = x;
1319: p->o_y = y;
1320: return(p);
1321: }
1322:
1323: struct obj *getpos(p, corner) /* find position of point */
1324: struct obj *p;
1325: int corner;
1326: {
1327: coord x, y, x1, y1;
1328:
1329: dprintf("getpos %o %d\n", p, corner);
1330: x = p->o_x;
1331: y = p->o_y;
1332: x1 = p->o_val[0];
1333: y1 = p->o_val[1];
1334: switch (p->o_type) {
1335: case PLACE:
1336: break;
1337: case BOX:
1338: switch (corner) {
1339: case NORTH: y += y1 / 2; break;
1340: case SOUTH: y -= y1 / 2; break;
1341: case EAST: x += x1 / 2; break;
1342: case WEST: x -= x1 / 2; break;
1343: case NE: x += x1 / 2; y += y1 / 2; break;
1344: case SW: x -= x1 / 2; y -= y1 / 2; break;
1345: case SE: x += x1 / 2; y -= y1 / 2; break;
1346: case NW: x -= x1 / 2; y += y1 / 2; break;
1347: }
1348: break;
1349: case CIRCLE:
1350: case ELLIPSE:
1351: switch (corner) {
1352: case NORTH: y += y1; break;
1353: case SOUTH: y -= y1; break;
1354: case EAST: x += x1; break;
1355: case WEST: x -= x1; break;
1356: case NE: x += 0.707 * x1; y += 0.707 * y1; break;
1357: case SE: x += 0.707 * x1; y -= 0.707 * y1; break;
1358: case NW: x -= 0.707 * x1; y += 0.707 * y1; break;
1359: case SW: x -= 0.707 * x1; y -= 0.707 * y1; break;
1360: }
1361: break;
1362: case LINE:
1363: case ARROW:
1364: case MOVE:
1365: switch (corner) {
1366: case START: break; /* already in place */
1367: case END: x = x1; y = y1; break;
1368: case CENTER: x = (x+x1)/2; y = (y+y1)/2; break;
1369: case NORTH: if (y1 > y) { x = x1; y = y1; } break;
1370: case SOUTH: if (y1 < y) { x = x1; y = y1; } break;
1371: case EAST: if (x1 > x) { x = x1; y = y1; } break;
1372: case WEST: if (x1 < x) { x = x1; y = y1; } break;
1373: }
1374: break;
1375: case ARC:
1376: switch (corner) {
1377: case START:
1378: if (p->o_attr & CW_ARC) {
1379: x = p->o_val[2]; y = p->o_val[3];
1380: } else {
1381: x = x1; y = y1;
1382: }
1383: break;
1384: case END:
1385: if (p->o_attr & CW_ARC) {
1386: x = x1; y = y1;
1387: } else {
1388: x = p->o_val[2]; y = p->o_val[3];
1389: }
1390: break;
1391: }
1392: break;
1393: case SPLINE:
1394: switch (corner) {
1395: case END:
1396: x = p->o_val[0];
1397: y = p->o_val[1];
1398: break;
1399: }
1400: break;
1401: }
1402: dprintf("getpos returns %d %d\n", x, y);
1403: return(makepos(x, y));
1404: }
1405:
1406: struct obj *gethere(n) /* make a place for curx,cury */
1407: {
1408: dprintf("gethere %d %d\n", curx, cury);
1409: return(makepos(curx, cury));
1410: }
1411:
1412: struct obj *getlast(n, t) /* find n-th previous occurrence of type t */
1413: int n, t;
1414: {
1415: int i, k;
1416: struct obj *p;
1417:
1418: k = n;
1419: for (i = nobj-1; i >= 0; i--) {
1420: p = objlist[i];
1421: if (p->o_type != t)
1422: continue;
1423: if (--k > 0)
1424: continue; /* not there yes */
1425: dprintf("got a last of x,y= %d,%d\n", p->o_x, p->o_y);
1426: return(p);
1427: }
1428: yyerror("there is no %dth last", n);
1429: }
1430:
1431: struct obj *getfirst(n, t) /* find n-th occurrence of type t */
1432: int n, t;
1433: {
1434: int i, k;
1435: struct obj *p;
1436:
1437: k = n;
1438: for (i = 0; i < nobj; i++) {
1439: p = objlist[i];
1440: if (p->o_type != t)
1441: continue;
1442: if (--k > 0)
1443: continue; /* not there yes */
1444: dprintf("got a first of x,y= %d,%d\n", p->o_x, p->o_y);
1445: return(p);
1446: yyerror("there is no %dth ", n);
1447: }
1448: }
1449:
1450: struct obj *fixpos(p, x, y)
1451: struct obj *p;
1452: coord x, y;
1453: {
1454: dprintf("fixpos returns %d %d\n", p->o_x + x, p->o_y + y);
1455: return(makepos(p->o_x + x, p->o_y + y));
1456: }
1457:
1458: struct obj *makenode(type, n)
1459: int type, n;
1460: {
1461: struct obj *p;
1462:
1463: p = (struct obj *) malloc(sizeof(struct obj) + (n-1)*sizeof(coord));
1464: if (p == NULL) {
1465: fprintf(stderr, "pic: out of space in makenode\n");
1466: exit(1);
1467: }
1468: p->o_type = type;
1469: p->o_count = n;
1470: p->o_mode = hvmode;
1471: p->o_x = curx;
1472: p->o_y = cury;
1473: p->o_nt1 = ntext1;
1474: p->o_nt2 = ntext;
1475: ntext1 = ntext; /* ready for next caller */
1476: p->o_attr = p->o_dotdash = p->o_ddval = 0;
1477: if (nobj >= MAXOBJ) {
1478: fprintf(stderr, "pic: objlist overflow\n");
1479: exit(1);
1480: }
1481: objlist[nobj++] = p;
1482: return(p);
1483: }
1484:
1485: extreme(x, y) /* record max and min x and y values */
1486: {
1487: if (x > xmax)
1488: xmax = x;
1489: if (y > ymax)
1490: ymax = y;
1491: if (x < xmin)
1492: xmin = x;
1493: if (y < ymin)
1494: ymin = y;
1495: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.