1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <ctype.h>
5 #include <errno.h>
6 #include "pic.h"
7 #include "y.tab.h"
8
9 Infile infile[10];
10 Infile *curfile = infile;
11
12 #define MAXSRC 50
13 Src src[MAXSRC]; /* input source stack */
14 Src *srcp = src;
15
16 void do_thru(void);
17 int nextchar(void);
18 int getarg(char *);
19 void freedef(char *);
20 int baldelim(int, char *);
21
pushsrc(int type,char * ptr)22 void pushsrc(int type, char *ptr) /* new input source */
23 {
24 if (++srcp >= src + MAXSRC)
25 ERROR "inputs nested too deep" FATAL;
26 srcp->type = type;
27 srcp->sp = ptr;
28 if (dbg > 1) {
29 printf("\n%3d ", srcp - src);
30 switch (srcp->type) {
31 case File:
32 printf("push file %s\n", ((Infile *)ptr)->fname);
33 break;
34 case Macro:
35 printf("push macro <%s>\n", ptr);
36 break;
37 case Char:
38 printf("push char <%c>\n", *ptr);
39 break;
40 case Thru:
41 printf("push thru\n");
42 break;
43 case String:
44 printf("push string <%s>\n", ptr);
45 break;
46 case Free:
47 printf("push free <%s>\n", ptr);
48 break;
49 default:
50 ERROR "pushed bad type %d", srcp->type FATAL;
51 }
52 }
53 }
54
popsrc(void)55 void popsrc(void) /* restore an old one */
56 {
57 if (srcp <= src)
58 ERROR "too many inputs popped" FATAL;
59 if (dbg > 1) {
60 printf("%3d ", srcp - src);
61 switch (srcp->type) {
62 case File:
63 printf("pop file\n");
64 break;
65 case Macro:
66 printf("pop macro\n");
67 break;
68 case Char:
69 printf("pop char <%c>\n", *srcp->sp);
70 break;
71 case Thru:
72 printf("pop thru\n");
73 break;
74 case String:
75 printf("pop string\n");
76 break;
77 case Free:
78 printf("pop free\n");
79 break;
80 default:
81 ERROR "pop weird input %d", srcp->type FATAL;
82 }
83 }
84 srcp--;
85 }
86
definition(char * s)87 void definition(char *s) /* collect definition for s and install */
88 /* definitions picked up lexically */
89 {
90 char *p;
91 struct symtab *stp;
92
93 p = delimstr("definition");
94 stp = lookup(s);
95 if (stp != NULL) { /* it's there before */
96 if (stp->s_type != DEFNAME) {
97 ERROR "%s used as variable and definition", s WARNING;
98 return;
99 }
100 free(stp->s_val.p);
101 stp->s_val.p = p;
102 } else {
103 YYSTYPE u;
104 u.p = p;
105 makevar(tostring(s), DEFNAME, u);
106 }
107 dprintf("installing %s as `%s'\n", s, p);
108 }
109
delimstr(char * s)110 char *delimstr(char *s) /* get body of X ... X */
111 /* message if too big */
112 {
113 int c, delim, rdelim, n, deep;
114 static char *buf = NULL;
115 static int nbuf = 0;
116 char *p;
117
118 if (buf == NULL)
119 buf = grow(buf, "buf", nbuf += 1000, sizeof(buf[0]));
120 while ((delim = input()) == ' ' || delim == '\t' || delim == '\n')
121 ;
122 rdelim = baldelim(delim, "{}"); /* could be "(){}[]`'" */
123 deep = 1;
124 for (p = buf; ; ) {
125 c = input();
126 if (c == rdelim)
127 if (--deep == 0)
128 break;
129 if (c == delim)
130 deep++;
131 if (p >= buf + nbuf) {
132 n = p - buf;
133 buf = grow(buf, "buf", nbuf += 1000, sizeof(buf[0]));
134 p = buf + n;
135 }
136 if (c == EOF)
137 ERROR "end of file in %s %c %.20s... %c", s, delim, buf, delim FATAL;
138 *p++ = c;
139 }
140 *p = '\0';
141 dprintf("delimstr %s %c <%s> %c\n", s, delim, buf, delim);
142 return tostring(buf);
143 }
144
baldelim(int c,char * s)145 baldelim(int c, char *s) /* replace c by balancing entry in s */
146 {
147 for ( ; *s; s += 2)
148 if (*s == c)
149 return s[1];
150 return c;
151 }
152
undefine(char * s)153 void undefine(char *s) /* undefine macro */
154 {
155 while (*s != ' ' && *s != '\t') /* skip "undef..." */
156 s++;
157 while (*s == ' ' || *s == '\t')
158 s++;
159 freedef(s);
160 }
161
162
163 Arg args[10]; /* argument frames */
164 Arg *argfp = args; /* frame pointer */
165 int argcnt; /* number of arguments seen so far */
166
dodef(struct symtab * stp)167 void dodef(struct symtab *stp) /* collect args and switch input to defn */
168 {
169 int i, len;
170 char *p;
171 Arg *ap;
172
173 ap = argfp+1;
174 if (ap >= args+10)
175 ERROR "arguments too deep" FATAL;
176 argcnt = 0;
177 if (input() != '(')
178 ERROR "disaster in dodef" FATAL;
179 if (ap->argval == 0)
180 ap->argval = malloc(1000);
181 for (p = ap->argval; (len = getarg(p)) != -1; p += len) {
182 ap->argstk[argcnt++] = p;
183 if (input() == ')')
184 break;
185 }
186 for (i = argcnt; i < MAXARGS; i++)
187 ap->argstk[i] = "";
188 if (dbg)
189 for (i = 0; i < argcnt; i++)
190 printf("arg %d.%d = <%s>\n", ap-args, i+1, ap->argstk[i]);
191 argfp = ap;
192 pushsrc(Macro, stp->s_val.p);
193 }
194
getarg(char * p)195 getarg(char *p) /* pick up single argument, store in p, return length */
196 {
197 int n, c, npar;
198
199 n = npar = 0;
200 for ( ;; ) {
201 c = input();
202 if (c == EOF)
203 ERROR "end of file in getarg" FATAL;
204 if (npar == 0 && (c == ',' || c == ')'))
205 break;
206 if (c == '"') /* copy quoted stuff intact */
207 do {
208 *p++ = c;
209 n++;
210 } while ((c = input()) != '"' && c != EOF);
211 else if (c == '(')
212 npar++;
213 else if (c == ')')
214 npar--;
215 n++;
216 *p++ = c;
217 }
218 *p = 0;
219 unput(c);
220 return(n + 1);
221 }
222
223 #define PBSIZE 2000
224 char pbuf[PBSIZE]; /* pushback buffer */
225 char *pb = pbuf-1; /* next pushed back character */
226
227 char ebuf[200]; /* collect input here for error reporting */
228 char *ep = ebuf;
229
230 int begin = 0;
231 extern int thru;
232 extern struct symtab *thrudef;
233 extern char *untilstr;
234
input(void)235 input(void)
236 {
237 register int c;
238
239 if (thru && begin) {
240 do_thru();
241 begin = 0;
242 }
243 c = nextchar();
244 if (dbg > 1)
245 printf(" <%c>", c);
246 if (ep >= ebuf + sizeof ebuf)
247 ep = ebuf;
248 return *(unsigned char *)ep++ = c;
249 }
250
nextchar(void)251 nextchar(void)
252 {
253 register int c;
254
255 c = 0;
256 loop:
257 switch (srcp->type) {
258 case Free: /* free string */
259 free(srcp->sp);
260 popsrc();
261 goto loop;
262 case Thru: /* end of pushed back line */
263 begin = 1;
264 popsrc();
265 c = '\n';
266 break;
267 case Char:
268 if (pb >= pbuf) {
269 c = *pb--;
270 popsrc();
271 break;
272 } else { /* can't happen? */
273 popsrc();
274 goto loop;
275 }
276 case String:
277 c = *srcp->sp++;
278 if (c == '\0') {
279 popsrc();
280 goto loop;
281 } else {
282 if (*srcp->sp == '\0') /* empty, so pop */
283 popsrc();
284 break;
285 }
286 case Macro:
287 c = *srcp->sp++;
288 if (c == '\0') {
289 if (--argfp < args)
290 ERROR "argfp underflow" FATAL;
291 popsrc();
292 goto loop;
293 } else if (c == '$' && isdigit(*srcp->sp)) {
294 int n = 0;
295 while (isdigit(*srcp->sp))
296 n = 10 * n + *srcp->sp++ - '0';
297 if (n > 0 && n <= MAXARGS)
298 pushsrc(String, argfp->argstk[n-1]);
299 goto loop;
300 }
301 break;
302 case File:
303 c = getc(curfile->fin);
304 if (c == EOF) {
305 if (curfile == infile)
306 ERROR "end of file inside .PS/.PE" FATAL;
307 if (curfile->fin != stdin) {
308 fclose(curfile->fin);
309 free(curfile->fname); /* assumes allocated */
310 }
311 curfile--;
312 printlf(curfile->lineno, curfile->fname);
313 popsrc();
314 thru = 0; /* chicken out */
315 thrudef = 0;
316 if (untilstr) {
317 free(untilstr);
318 untilstr = 0;
319 }
320 goto loop;
321 }
322 if (c == '\n')
323 curfile->lineno++;
324 break;
325 }
326 return c;
327 }
328
do_thru(void)329 void do_thru(void) /* read one line, make into a macro expansion */
330 {
331 int c, i;
332 char *p;
333 Arg *ap;
334
335 ap = argfp+1;
336 if (ap >= args+10)
337 ERROR "arguments too deep" FATAL;
338 if (ap->argval == NULL)
339 ap->argval = malloc(1000);
340 p = ap->argval;
341 argcnt = 0;
342 c = nextchar();
343 if (thru == 0) { /* end of file was seen, so thru is done */
344 unput(c);
345 return;
346 }
347 for ( ; c != '\n' && c != EOF; ) {
348 if (c == ' ' || c == '\t') {
349 c = nextchar();
350 continue;
351 }
352 ap->argstk[argcnt++] = p;
353 if (c == '"') {
354 do {
355 *p++ = c;
356 if ((c = nextchar()) == '\\') {
357 *p++ = c;
358 *p++ = nextchar();
359 c = nextchar();
360 }
361 } while (c != '"' && c != '\n' && c != EOF);
362 *p++ = '"';
363 if (c == '"')
364 c = nextchar();
365 } else {
366 do {
367 *p++ = c;
368 } while ((c = nextchar())!=' ' && c!='\t' && c!='\n' && c!=',' && c!=EOF);
369 if (c == ',')
370 c = nextchar();
371 }
372 *p++ = '\0';
373 }
374 if (c == EOF)
375 ERROR "unexpected end of file in do_thru" FATAL;
376 if (argcnt == 0) { /* ignore blank line */
377 pushsrc(Thru, (char *) 0);
378 return;
379 }
380 for (i = argcnt; i < MAXARGS; i++)
381 ap->argstk[i] = "";
382 if (dbg)
383 for (i = 0; i < argcnt; i++)
384 printf("arg %d.%d = <%s>\n", ap-args, i+1, ap->argstk[i]);
385 if (strcmp(ap->argstk[0], ".PE") == 0) {
386 thru = 0;
387 thrudef = 0;
388 pushsrc(String, "\n.PE\n");
389 return;
390 }
391 if (untilstr && strcmp(ap->argstk[0], untilstr) == 0) {
392 thru = 0;
393 thrudef = 0;
394 free(untilstr);
395 untilstr = 0;
396 return;
397 }
398 pushsrc(Thru, (char *) 0);
399 dprintf("do_thru pushing back <%s>\n", thrudef->s_val.p);
400 argfp = ap;
401 pushsrc(Macro, thrudef->s_val.p);
402 }
403
unput(int c)404 unput(int c)
405 {
406 if (++pb >= pbuf + sizeof pbuf)
407 ERROR "pushback overflow" FATAL;
408 if (--ep < ebuf)
409 ep = ebuf + sizeof(ebuf) - 1;
410 *pb = c;
411 pushsrc(Char, pb);
412 return c;
413 }
414
pbstr(char * s)415 void pbstr(char *s)
416 {
417 pushsrc(String, s);
418 }
419
errcheck(double x,char * s)420 double errcheck(double x, char *s)
421 {
422 extern int errno;
423
424 if (errno == EDOM) {
425 errno = 0;
426 ERROR "%s argument out of domain", s WARNING;
427 } else if (errno == ERANGE) {
428 errno = 0;
429 ERROR "%s result out of range", s WARNING;
430 }
431 return x;
432 }
433
434 char errbuf[200];
435
436 void eprint(void);
437
yyerror(char * s)438 void yyerror(char *s)
439 {
440 extern char *cmdname;
441 int ern = errno; /* cause some libraries clobber it */
442
443 if (synerr)
444 return;
445 fflush(stdout);
446 fprintf(stderr, "%s: %s", cmdname, s);
447 if (ern > 0) {
448 errno = ern;
449 perror("???");
450 }
451 fprintf(stderr, " near %s:%d\n",
452 curfile->fname, curfile->lineno+1);
453 eprint();
454 synerr = 1;
455 errno = 0;
456 }
457
eprint(void)458 void eprint(void) /* try to print context around error */
459 {
460 char *p, *q;
461
462 p = ep - 1;
463 if (p > ebuf && *p == '\n')
464 p--;
465 for ( ; p >= ebuf && *p != '\n'; p--)
466 ;
467 while (*p == '\n')
468 p++;
469 fprintf(stderr, " context is\n\t");
470 for (q=ep-1; q>=p && *q!=' ' && *q!='\t' && *q!='\n'; q--)
471 ;
472 while (p < q)
473 putc(*p++, stderr);
474 fprintf(stderr, " >>> ");
475 while (p < ep)
476 putc(*p++, stderr);
477 fprintf(stderr, " <<< ");
478 while (pb >= pbuf)
479 putc(*pb--, stderr);
480 fgets(ebuf, sizeof ebuf, curfile->fin);
481 fprintf(stderr, "%s", ebuf);
482 pbstr("\n.PE\n"); /* safety first */
483 ep = ebuf;
484 }
485
486 int
yywrap(void)487 yywrap(void)
488 {
489 return 1; /* read eof; did not switch inputs */
490 }
491
492 char *newfile = 0; /* filename for file copy */
493 char *untilstr = 0; /* string that terminates a thru */
494 int thru = 0; /* 1 if copying thru macro */
495 struct symtab *thrudef = 0; /* macro being used */
496
copyfile(char * s)497 void copyfile(char *s) /* remember file to start reading from */
498 {
499 newfile = s;
500 }
501
copydef(struct symtab * p)502 void copydef(struct symtab *p) /* remember macro symtab ptr */
503 {
504 thrudef = p;
505 }
506
copythru(char * s)507 struct symtab *copythru(char *s) /* collect the macro name or body for thru */
508 {
509 struct symtab *p;
510 char *q, *addnewline(char *);
511
512 p = lookup(s);
513 if (p != NULL) {
514 if (p->s_type == DEFNAME) {
515 p->s_val.p = addnewline(p->s_val.p);
516 return p;
517 } else
518 ERROR "%s used as define and name", s FATAL;
519 }
520 /* have to collect the definition */
521 pbstr(s); /* first char is the delimiter */
522 q = delimstr("thru body");
523 s = "nameless";
524 p = lookup(s);
525 if (p != NULL) {
526 if (p->s_val.p)
527 free(p->s_val.p);
528 p->s_val.p = q;
529 } else {
530 YYSTYPE u;
531 u.p = q;
532 p = makevar(tostring(s), DEFNAME, u);
533 }
534 p->s_val.p = addnewline(p->s_val.p);
535 dprintf("installing %s as `%s'\n", s, p->s_val.p);
536 return p;
537 }
538
addnewline(char * p)539 char *addnewline(char *p) /* add newline to end of p */
540 {
541 int n;
542
543 n = strlen(p);
544 if (p[n-1] != '\n') {
545 p = realloc(p, n+2);
546 p[n] = '\n';
547 p[n+1] = '\0';
548 }
549 return p;
550 }
551
copyuntil(char * s)552 void copyuntil(char *s) /* string that terminates a thru */
553 {
554 untilstr = s;
555 }
556
copy(void)557 void copy(void) /* begin input from file, etc. */
558 {
559 FILE *fin;
560
561 if (newfile) {
562 if ((fin = fopen(newfile, "r")) == NULL)
563 ERROR "can't open file %s", newfile FATAL;
564 curfile++;
565 curfile->fin = fin;
566 curfile->fname = newfile;
567 curfile->lineno = 0;
568 printlf(1, curfile->fname);
569 pushsrc(File, curfile->fname);
570 newfile = 0;
571 }
572 if (thrudef) {
573 thru = 1;
574 begin = 1; /* wrong place */
575 }
576 }
577
578 char shellbuf[1000], *shellp;
579
shell_init(void)580 void shell_init(void) /* set up to interpret a shell command */
581 {
582 sprintf(shellbuf, "rc -c '");
583 shellp = shellbuf + strlen(shellbuf);
584 }
585
shell_text(char * s)586 void shell_text(char *s) /* add string to command being collected */
587 {
588 while (*shellp++ = *s++)
589 ;
590 shellp--;
591 }
592
shell_exec(void)593 void shell_exec(void) /* do it */
594 {
595 *shellp++ = '\'';
596 *shellp = '\0';
597 system(shellbuf);
598 }
599