1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1986-2011 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Eclipse Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.eclipse.org/org/documents/epl-v10.html *
11 * (with md5 checksum b35adb5213ca9657e911e9befb180842) *
12 * *
13 * Information and Software Systems Research *
14 * AT&T Research *
15 * Florham Park NJ *
16 * *
17 * Glenn Fowler <gsf@research.att.com> *
18 * *
19 ***********************************************************************/
20 #pragma prototyped
21 /*
22 * Glenn Fowler
23 * AT&T Research
24 *
25 * preprocessor control directive support
26 */
27
28 #include "pplib.h"
29
30 #include <regex.h>
31
32 #define TOKOP_DUP (1<<0)
33 #define TOKOP_STRING (1<<1)
34 #define TOKOP_UNSET (1<<2)
35
36 struct edit
37 {
38 struct edit* next;
39 regex_t re;
40 };
41
42 struct map
43 {
44 struct map* next;
45 regex_t re;
46 struct edit* edit;
47 };
48
49 #define RESTORE (COLLECTING|CONDITIONAL|DEFINITION|DIRECTIVE|DISABLE|EOF2NL|HEADER|NOSPACE|NOVERTICAL|PASSEOF|STRIP)
50
51 /*
52 * common predicate assertion operations
53 * op is DEFINE or UNDEF
54 */
55
56 static void
assert(int op,char * pred,char * args)57 assert(int op, char* pred, char* args)
58 {
59 register struct pplist* a;
60 register struct ppsymbol* sym;
61 register struct pplist* p;
62 register struct pplist* q;
63
64 if (!args) switch (op)
65 {
66 case DEFINE:
67 goto mark;
68 case UNDEF:
69 a = 0;
70 goto unmark;
71 }
72 if (a = (struct pplist*)hashget(pp.prdtab, pred))
73 {
74 p = 0;
75 q = a;
76 while (q)
77 {
78 if (streq(q->value, args))
79 {
80 if (op == DEFINE) return;
81 q = q->next;
82 if (p) p->next = q;
83 else a = q;
84 }
85 else
86 {
87 p = q;
88 q = q->next;
89 }
90 }
91 if (op == UNDEF)
92 {
93 unmark:
94 hashput(pp.prdtab, pred, a);
95 if (sym = ppsymref(pp.symtab, pred))
96 sym->flags &= ~SYM_PREDICATE;
97 return;
98 }
99 }
100 if (op == DEFINE)
101 {
102 p = newof(0, struct pplist, 1, 0);
103 p->next = a;
104 p->value = strdup(args);
105 hashput(pp.prdtab, NiL, p);
106 mark:
107 if ((pp.state & COMPILE) && pp.truncate) return;
108 if (sym = ppsymset(pp.symtab, pred))
109 sym->flags |= SYM_PREDICATE;
110 }
111 }
112
113 /*
114 * tokenize string ppop()
115 *
116 * op PP_* op
117 * name option name
118 * s string of option values
119 * n option sense
120 * flags TOKOP_* flags
121 */
122
123 static void
tokop(int op,char * name,register char * s,register int n,int flags)124 tokop(int op, char* name, register char* s, register int n, int flags)
125 {
126 register int c;
127 register char* t;
128
129 if (!(flags & TOKOP_UNSET) && !n) error(2, "%s: option cannot be unset", name);
130 else if (!s) ppop(op, s, n);
131 else if (flags & TOKOP_STRING)
132 {
133 PUSH_LINE(s);
134 for (;;)
135 {
136 pp.state &= ~NOSPACE;
137 c = pplex();
138 pp.state |= NOSPACE;
139 if (!c) break;
140 if (c != ' ')
141 ppop(op, (flags & TOKOP_DUP) ? strdup(pp.token) : pp.token, n);
142 }
143 POP_LINE();
144 }
145 else do
146 {
147 while (*s == ' ') s++;
148 for (t = s; *t && *t != ' '; t++);
149 if (*t) *t++ = 0;
150 else t = 0;
151 if (*s) ppop(op, (flags & TOKOP_DUP) ? strdup(s) : s, n);
152 } while (s = t);
153 }
154
155 /*
156 * return symbol pointer for next token macro (re)definition
157 */
158
159 static struct ppsymbol*
macsym(int tok)160 macsym(int tok)
161 {
162 register struct ppsymbol* sym;
163
164 if (tok != T_ID)
165 {
166 error(2, "%s: invalid macro name", pptokstr(pp.token, 0));
167 return 0;
168 }
169 sym = pprefmac(pp.token, REF_CREATE);
170 if ((sym->flags & SYM_FINAL) && (pp.mode & HOSTED)) return 0;
171 if (sym->flags & (SYM_ACTIVE|SYM_READONLY))
172 {
173 if (!(pp.option & ALLPOSSIBLE))
174 error(2, "%s: macro is %s", sym->name, (sym->flags & SYM_READONLY) ? "readonly" : "active");
175 return 0;
176 }
177 if (!sym->macro) sym->macro = newof(0, struct ppmacro, 1, 0);
178 return sym;
179 }
180
181 /*
182 * get one space canonical pplex() line, sans '\n', and place in p
183 * x is max+1 pos in p
184 * 0 returned if line too large
185 * otherwise end of p ('\0') returned
186 */
187
188 static char*
getline(register char * p,char * x,int disable)189 getline(register char* p, char* x, int disable)
190 {
191 register int c;
192 register char* s;
193 char* b;
194 long restore;
195
196 restore = pp.state & (NOSPACE|STRIP);
197 pp.state &= ~(NEWLINE|NOSPACE|STRIP);
198 pp.state |= EOF2NL;
199 b = p;
200 while ((c = pplex()) != '\n')
201 {
202 if (disable)
203 {
204 if (c == ' ')
205 /*ignore*/;
206 else if (disable == 1)
207 disable = (c == T_ID && streq(pp.token, pp.pass)) ? 2 : 0;
208 else
209 {
210 disable = 0;
211 if (c == ':')
212 pp.state |= DISABLE;
213 }
214 }
215 s = pp.token;
216 while (*p = *s++)
217 if (++p >= x)
218 {
219 p = 0;
220 goto done;
221 }
222 }
223 if (p > b && *(p - 1) == ' ')
224 p--;
225 if (p >= x)
226 p = 0;
227 else
228 *p = 0;
229 done:
230 pp.state &= ~(NOSPACE|STRIP);
231 pp.state |= restore;
232 return p;
233 }
234
235 /*
236 * regex error handler
237 */
238
239 void
regfatal(regex_t * p,int level,int code)240 regfatal(regex_t* p, int level, int code)
241 {
242 char buf[128];
243
244 regerror(code, p, buf, sizeof(buf));
245 regfree(p);
246 error(level, "regular expression: %s", buf);
247 }
248
249 /*
250 * process a single directive line
251 */
252
253 int
ppcontrol(void)254 ppcontrol(void)
255 {
256 register char* p;
257 register int c;
258 register int n;
259 register char* s;
260 register struct ppmacro* mac;
261 register struct ppsymbol* sym;
262 struct edit* edit;
263 struct map* map;
264 struct ppfile* fp;
265 int o;
266 int directive;
267 long restore;
268 struct pptuple* rp;
269 struct pptuple* tp;
270 char* v;
271 int emitted;
272
273 union
274 {
275 struct map* best;
276 struct ppinstk* inp;
277 struct pplist* list;
278 char* string;
279 struct ppsymbol* symbol;
280 int type;
281 PPLINESYNC linesync;
282 } var;
283
284 static char __va_args__[] = "__VA_ARGS__";
285 static int i0;
286 static int i1;
287 static int i2;
288 static int i3;
289 static int i4;
290
291 static long n1;
292 static long n2;
293 static long n3;
294
295 static char* p0;
296 static char* p1;
297 static char* p2;
298 static char* p3;
299 static char* p4;
300 static char* p5;
301 static char* p6;
302
303 static struct ppmacro old;
304 static char* formargs[MAXFORMALS];
305 #if MACKEYARGS
306 static char* formvals[MAXFORMALS];
307 #endif
308
309 emitted = 0;
310 if (pp.state & SKIPCONTROL) pp.level--;
311 restore = (pp.state & RESTORE)|NEWLINE;
312 if (pp.state & PASSTHROUGH) restore |= DISABLE;
313 else restore &= ~DISABLE;
314 pp.state &= ~(NEWLINE|RESTORE|SKIPCONTROL);
315 pp.state |= DIRECTIVE|DISABLE|EOF2NL|NOSPACE|NOVERTICAL;
316 #if COMPATIBLE
317 if ((pp.state & (COMPATIBILITY|STRICT)) == COMPATIBILITY || (pp.mode & HOSTED)) pp.state &= ~NOVERTICAL;
318 #else
319 if (pp.mode & HOSTED) pp.state &= ~NOVERTICAL;
320 #endif
321 switch (c = pplex())
322 {
323 case T_DECIMAL:
324 case T_OCTAL:
325 if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
326 error(1, "# <line> [ \"<file>\" [ <type> ] ]: non-standard directive");
327 directive = INCLUDE;
328 goto linesync;
329 case T_ID:
330 switch (directive = (int)hashref(pp.dirtab, pp.token))
331 {
332 case ELIF:
333 else_if:
334 if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
335 goto eatdirective;
336 if (pp.control <= pp.in->control)
337 {
338 error(2, "no matching #%s for #%s", dirname(IF), dirname(ELIF));
339 goto eatdirective;
340 }
341 if (pp.control == (pp.in->control + 1)) pp.in->flags |= IN_noguard;
342 if (*pp.control & HADELSE)
343 {
344 error(2, "invalid #%s after #%s", dirname(ELIF), dirname(ELSE));
345 *pp.control |= SKIP;
346 goto eatdirective;
347 }
348 if (*pp.control & KEPT)
349 {
350 *pp.control |= SKIP;
351 goto eatdirective;
352 }
353 if (directive == IFDEF || directive == IFNDEF)
354 {
355 *pp.control &= ~SKIP;
356 goto else_ifdef;
357 }
358 conditional:
359 if (ppexpr(&i1))
360 {
361 *pp.control &= ~SKIP;
362 *pp.control |= KEPT;
363 }
364 else *pp.control |= SKIP;
365 c = (pp.state & NEWLINE) ? '\n' : ' ';
366 goto eatdirective;
367 case ELSE:
368 if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
369 goto eatdirective;
370 if ((pp.option & ELSEIF) && (c = pplex()) == T_ID && ((n = (int)hashref(pp.dirtab, pp.token)) == IF || n == IFDEF || n == IFNDEF))
371 {
372 error(1, "#%s %s is non-standard -- use #%s", dirname(directive), dirname(n), dirname(ELIF));
373 directive = n;
374 goto else_if;
375 }
376 if (pp.control <= pp.in->control) error(2, "no matching #%s for #%s", dirname(IF), dirname(ELSE));
377 else
378 {
379 if (pp.control == (pp.in->control + 1)) pp.in->flags |= IN_noguard;
380 if (!(*pp.control & KEPT))
381 {
382 *pp.control &= ~SKIP;
383 *pp.control |= HADELSE|KEPT;
384 }
385 else
386 {
387 if (*pp.control & HADELSE) error(2, "more than one #%s for #%s", dirname(ELSE), dirname(IF));
388 *pp.control |= HADELSE|SKIP;
389 }
390 }
391 goto enddirective;
392 case ENDIF:
393 if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
394 goto eatdirective;
395 if (pp.control <= pp.in->control) error(2, "no matching #%s for #%s", dirname(IF), dirname(ENDIF));
396 else if (--pp.control == pp.in->control && pp.in->symbol)
397 {
398 if (pp.in->flags & IN_endguard) pp.in->flags |= IN_noguard;
399 else
400 {
401 pp.in->flags &= ~IN_tokens;
402 pp.in->flags |= IN_endguard;
403 }
404 }
405 goto enddirective;
406 case IF:
407 case IFDEF:
408 case IFNDEF:
409 if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev)
410 goto eatdirective;
411 pushcontrol();
412 SETIFBLOCK(pp.control);
413 if (*pp.control & SKIP)
414 {
415 *pp.control |= KEPT;
416 goto eatdirective;
417 }
418 if (directive == IF) goto conditional;
419 else_ifdef:
420 if ((c = pplex()) == T_ID)
421 {
422 sym = pprefmac(pp.token, REF_IF);
423 if (directive == IFNDEF && pp.control == pp.in->control + 1)
424 {
425 if (pp.in->flags & (IN_defguard|IN_endguard))
426 pp.in->flags |= IN_noguard;
427 else
428 {
429 pp.in->flags |= IN_defguard;
430 if (!(pp.in->flags & IN_tokens))
431 pp.in->symbol = sym ? sym : pprefmac(pp.token, REF_CREATE);
432 }
433 }
434 }
435 else
436 {
437 sym = 0;
438 if (!(pp.mode & HOSTED))
439 error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
440 }
441 *pp.control |= ((sym != 0) == (directive == IFDEF)) ? KEPT : SKIP;
442 goto enddirective;
443 case INCLUDE:
444 if (*pp.control & SKIP)
445 {
446 pp.state |= HEADER;
447 c = pplex();
448 pp.state &= ~HEADER;
449 goto eatdirective;
450 }
451 pp.state &= ~DISABLE;
452 pp.state |= HEADER|STRIP;
453 pp.in->flags |= IN_noguard;
454 switch (c = pplex())
455 {
456 case T_STRING:
457 p = pp.token;
458 do pp.token = pp.toknxt; while ((c = pplex()) == T_STRING);
459 *pp.token = 0;
460 pp.token = p;
461 /*FALLTHROUGH*/
462 case T_HEADER:
463 header:
464 if (!*pp.token)
465 {
466 error(2, "#%s: null file name", dirname(INCLUDE));
467 break;
468 }
469 if (*pp.token == '/' && !(pp.mode & (HOSTED|RELAX)))
470 error(1, "#%s: reference to %s is not portable", dirname(INCLUDE), pp.token);
471 n = ppsearch(pp.token, c, SEARCH_INCLUDE);
472 break;
473 case '<':
474 /*
475 * HEADEREXPAND|HEADEREXPANDALL gets us here
476 */
477
478 if (!(p = pp.hdrbuf) && !(p = pp.hdrbuf = newof(0, char, MAXTOKEN, 0)))
479 error(3, "out of space");
480 pp.state &= ~NOSPACE;
481 while ((c = pplex()) && c != '>')
482 {
483 v = p + 1;
484 STRCOPY(p, pp.token, s);
485 if (p == v && *(p - 1) == ' ' && pp.in->type != IN_MACRO)
486 p--;
487 }
488 pp.state |= NOSPACE;
489 *p++ = 0;
490 memcpy(pp.token, pp.hdrbuf, p - pp.hdrbuf);
491 c = T_HEADER;
492 goto header;
493 default:
494 error(2, "#%s: \"...\" or <...> argument expected", dirname(INCLUDE));
495 goto eatdirective;
496 }
497 goto enddirective;
498 case 0:
499 {
500 regmatch_t match[10];
501
502 /*UNDENT*/
503 p = pp.valbuf;
504 *p++ = '#';
505 STRCOPY(p, pp.token, s);
506 p0 = p;
507 pp.mode |= EXPOSE;
508 pp.state |= HEADER;
509 p6 = getline(p, &pp.valbuf[MAXTOKEN], 0);
510 pp.state &= ~HEADER;
511 pp.mode &= ~EXPOSE;
512 if (!p6)
513 {
514 *p0 = 0;
515 error(2, "%s: directive too long", pp.valbuf);
516 c = 0;
517 goto eatdirective;
518 }
519 p1 = p2 = p3 = p4 = 0;
520 p5 = *p ? p + 1 : 0;
521 checkmap:
522 i0 = *p0;
523 p = pp.valbuf;
524 var.best = 0;
525 n = 0;
526 for (map = (struct map*)pp.maps; map; map = map->next)
527 if (!(i1 = regexec(&map->re, p, elementsof(match), match, 0)))
528 {
529 if ((c = match[0].rm_eo - match[0].rm_so) > n)
530 {
531 n = c;
532 var.best = map;
533 }
534 }
535 else if (i1 != REG_NOMATCH)
536 regfatal(&map->re, 4, i1);
537 c = '\n';
538 if (map = var.best)
539 {
540 if ((pp.state & (STRICT|WARN)) && !(pp.mode & (HOSTED|RELAX)))
541 {
542 *p0 = 0;
543 if (!(pp.state & WARN) || strcmp(p + 1, dirname(PRAGMA)))
544 error(1, "%s: non-standard directive", p);
545 *p0 = i0;
546 }
547 if (!(*pp.control & SKIP))
548 {
549 n = 0;
550 for (edit = map->edit; edit; edit = edit->next)
551 if (!(i0 = regexec(&edit->re, p, elementsof(match), match, 0)))
552 {
553 n++;
554 if (i0 = regsubexec(&edit->re, p, elementsof(match), match))
555 regfatal(&edit->re, 4, i0);
556 p = edit->re.re_sub->re_buf;
557 if (edit->re.re_sub->re_flags & REG_SUB_STOP)
558 break;
559 }
560 else if (i0 != REG_NOMATCH)
561 regfatal(&edit->re, 4, i0);
562 if (n && *p)
563 {
564 p1 = s = oldof(0, char, 0, strlen(p) + 32);
565 while (*s = *p++) s++;
566 debug((-4, "map: %s", p1));
567 *s++ = '\n';
568 *s = 0;
569 error_info.line++;
570 PUSH_RESCAN(p1);
571 error_info.line--;
572 directive = LINE;
573 }
574 }
575 goto donedirective;
576 }
577 if (directive != PRAGMA && (!(*pp.control & SKIP) || !(pp.mode & (HOSTED|RELAX))))
578 {
579 *p0 = 0;
580 error(1, "%s: unknown directive", pptokstr(pp.valbuf, 0));
581 *p0 = i0;
582 }
583 pass:
584 if (!(*pp.control & SKIP) && pp.pragma && !(pp.state & NOTEXT) && (directive == PRAGMA || !(pp.mode & INIT)))
585 {
586 *p0 = 0;
587 if (p2) *p2 = 0;
588 if (p4)
589 {
590 if (p4 == p5)
591 {
592 p5 = strcpy(pp.tmpbuf, p5);
593 if (p = strchr(p5, MARK))
594 {
595 s = p;
596 while (*p)
597 if ((*s++ = *p++) == MARK && *p == MARK) p++;
598 *s = 0;
599 }
600 }
601 *p4 = 0;
602 }
603 if (p = (char*)memchr(pp.valbuf + 1, MARK, p6 - pp.valbuf - 1))
604 {
605 s = p;
606 while (p < p6) switch (*s++ = *p++)
607 {
608 case 0:
609 s = p;
610 break;
611 case MARK:
612 p++;
613 break;
614 }
615 *s = 0;
616 }
617 (*pp.pragma)(pp.valbuf + 1, p1, p3, p5, (pp.state & COMPILE) || (pp.mode & INIT) != 0);
618 emitted = 1;
619 }
620 goto donedirective;
621
622 /*INDENT*/
623 }
624 }
625 if (*pp.control & SKIP) goto eatdirective;
626 switch (directive)
627 {
628 #if MACDEF
629 case ENDMAC:
630 c = pplex();
631 error(2, "no matching #%s for #%s", dirname(MACDEF), dirname(ENDMAC));
632 goto enddirective;
633 #endif
634 #if MACDEF
635 case MACDEF:
636 if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
637 error(1, "#%s: non-standard directive", pp.token);
638 #endif
639 /* FALLTHROUGH */
640 case DEFINE:
641 n2 = error_info.line;
642 if ((c = pplex()) == '#' && directive == DEFINE)
643 goto assertion;
644 if (c == '<')
645 {
646 n = 1;
647 c = pplex();
648 }
649 else
650 n = 0;
651 if (!(sym = macsym(c)))
652 goto eatdirective;
653 if (pp.truncate)
654 ppfsm(FSM_MACRO, pp.token);
655 mac = sym->macro;
656 if ((pp.option & ALLPOSSIBLE) && !pp.in->prev->prev && mac->value)
657 goto eatdirective;
658 if (n)
659 goto tuple;
660 old = *mac;
661 i0 = sym->flags;
662 sym->flags &= ~(SYM_BUILTIN|SYM_EMPTY|SYM_FINAL|SYM_FUNCTION|SYM_INIT|SYM_INITIAL|SYM_MULTILINE|SYM_NOEXPAND|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
663 #if MACDEF
664 if (directive == MACDEF)
665 sym->flags |= SYM_MULTILINE;
666 #endif
667 mac->arity = 0;
668 mac->formals = 0;
669 mac->value = 0;
670 pp.state &= ~NOSPACE;
671 pp.state |= DEFINITION|NOEXPAND;
672 switch (c = pplex())
673 {
674 case '(':
675 sym->flags |= SYM_FUNCTION;
676 pp.state |= NOSPACE;
677 #if MACKEYARGS
678 if (pp.option & KEYARGS)
679 {
680 n = 2 * MAXTOKEN;
681 p = mac->formals = oldof(0, char, 0, n);
682 if ((c = pplex()) == T_ID) for (;;)
683 {
684 if (mac->arity < MAXFORMALS)
685 {
686 if (mac->arity) p++;
687 formargs[mac->arity] = p;
688 STRAPP(p, pp.token, s);
689 formvals[mac->arity++] = p1 = p;
690 if (mac->arity == 1) *p++ = ' ';
691 *p++ = ' ';
692 *p = 0;
693 }
694 else error(2, "%s: formal argument %s ignored", sym->name, pp.token);
695 switch (c = pplex())
696 {
697 case '=':
698 c = pplex();
699 break;
700 case ',':
701 break;
702 default:
703 goto endformals;
704 }
705 pp.state &= ~NOSPACE;
706 p0 = 0;
707 for (;;)
708 {
709 switch (c)
710 {
711 case '\n':
712 goto endformals;
713 case '(':
714 p0++;
715 break;
716 case ')':
717 if (!p0--)
718 {
719 if (p > formvals[mac->arity - 1] && *(p - 1) == ' ') *--p = 0;
720 goto endformals;
721 }
722 break;
723 case ',':
724 if (!p0)
725 {
726 if (p > formvals[mac->arity - 1] && *(p - 1) == ' ') *--p = 0;
727 goto nextformal;
728 }
729 break;
730 case ' ':
731 if (p > formvals[mac->arity - 1] && *(p - 1) == ' ') continue;
732 break;
733 }
734 STRCOPY(p, pp.token, s);
735 if (p > &mac->formals[n - MAXTOKEN] && (s = newof(mac->formals, char, n += MAXTOKEN, 0)) != mac->formals)
736 {
737 n1 = s - mac->formals;
738 for (n = 0; n < mac->arity; n++)
739 {
740 formargs[n] += n1;
741 formvals[n] += n1;
742 }
743 c = p - mac->formals;
744 mac->formals = s;
745 p = mac->formals + c;
746 }
747 c = pplex();
748 }
749 nextformal:
750 pp.state |= NOSPACE;
751 if ((c = pplex()) != T_ID)
752 {
753 c = ',';
754 break;
755 }
756 }
757 endformals: /*NOP*/;
758 }
759 else
760 #endif
761 {
762 p = mac->formals = oldof(0, char, 0, MAXFORMALS * (MAXID + 1));
763 c = pplex();
764 #if COMPATIBLE
765 if ((pp.state & COMPATIBILITY) && c == ',')
766 {
767 if ((pp.state & WARN) && !(pp.mode & HOSTED))
768 error(1, "%s: macro formal argument expected", sym->name);
769 while ((c = pplex()) == ',');
770 }
771 #endif
772 for (;;)
773 {
774 if (c == T_VARIADIC)
775 {
776 if (sym->flags & SYM_VARIADIC)
777 error(2, "%s: %s: duplicate macro formal argument", sym->name, pp.token);
778 sym->flags |= SYM_VARIADIC;
779 v = __va_args__;
780 }
781 else if (c == T_ID)
782 {
783 v = pp.token;
784 if (sym->flags & SYM_VARIADIC)
785 error(2, "%s: %s: macro formal argument cannot follow ...", sym->name, v);
786 else if (streq(v, __va_args__))
787 error(2, "%s: %s: invalid macro formal argument", sym->name, v);
788 }
789 else
790 break;
791 if (mac->arity < MAXFORMALS)
792 {
793 for (n = 0; n < mac->arity; n++)
794 if (streq(formargs[n], v))
795 error(2, "%s: %s: duplicate macro formal argument", sym->name, v);
796 formargs[mac->arity++] = p;
797 STRAPP(p, v, s);
798 }
799 else
800 error(2, "%s: %s: macro formal argument ignored", sym->name, v);
801 if ((c = pplex()) == ',')
802 {
803 c = pplex();
804 #if COMPATIBLE
805 if ((pp.state & COMPATIBILITY) && c == ',')
806 {
807 if ((pp.state & WARN) && !(pp.mode & HOSTED))
808 error(1, "%s: macro formal argument expected", sym->name);
809 while ((c = pplex()) == ',');
810 }
811 #endif
812 }
813 else if (c != T_VARIADIC)
814 break;
815 else
816 {
817 if (sym->flags & SYM_VARIADIC)
818 error(2, "%s: %s: duplicate macro formal argument", sym->name, pp.token);
819 sym->flags |= SYM_VARIADIC;
820 c = pplex();
821 break;
822 }
823 }
824 if (mac->arity && (s = newof(mac->formals, char, p - mac->formals, 0)) != mac->formals)
825 {
826 n1 = s - mac->formals;
827 for (n = 0; n < mac->arity; n++)
828 formargs[n] += n1;
829 mac->formals = s;
830 }
831 }
832 if (!mac->arity)
833 {
834 free(mac->formals);
835 mac->formals = 0;
836 }
837 switch (c)
838 {
839 case ')':
840 #if MACKEYARGS
841 pp.state |= NOEXPAND|NOSPACE;
842 #else
843 pp.state |= NOEXPAND;
844 #endif
845 c = pplex();
846 break;
847 default:
848 error(2, "%s: invalid macro formal argument list", sym->name);
849 if (mac->formals)
850 {
851 free(mac->formals);
852 mac->formals = 0;
853 mac->arity = 0;
854 }
855 free(mac);
856 sym->macro = 0;
857 goto eatdirective;
858 }
859 pp.state &= ~NOSPACE;
860 break;
861 case ' ':
862 case '\t':
863 c = pplex();
864 break;
865 }
866 n = 2 * MAXTOKEN;
867 #if MACKEYARGS
868 p1 = p;
869 #endif
870 p = mac->value = oldof(0, char, 0, n);
871 var.type = 0;
872 n1 = 0;
873 #if MACDEF
874 i2 = i3 = 0;
875 n3 = pp.state;
876 #endif
877 if ((pp.option & PLUSPLUS) && (pp.state & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
878 switch (c)
879 {
880 case '+':
881 case '-':
882 case '&':
883 case '|':
884 case '<':
885 case '>':
886 case ':':
887 case '=':
888 *p++ = ' ';
889 break;
890 }
891 o = 0;
892 for (;;)
893 {
894 switch (c)
895 {
896 case T_ID:
897 for (c = 0; c < mac->arity; c++)
898 if (streq(formargs[c], pp.token))
899 {
900 #if COMPATIBLE
901 if (!(pp.state & COMPATIBILITY))
902 #endif
903 if (var.type != TOK_TOKCAT && p > mac->value && *(p - 1) != ' ' && !(pp.option & PRESERVE)) *p++ = ' ';
904 *p++ = MARK;
905 #if COMPATIBLE
906 if ((pp.state & (COMPATIBILITY|TRANSITION)) == COMPATIBILITY) *p++ = 'C';
907 else
908 #endif
909 *p++ = (n1 || var.type == TOK_TOKCAT) ? 'C' : 'A';
910 *p++ = c + ARGOFFSET;
911 if ((pp.state & WARN) && !(pp.mode & (HOSTED|RELAX)) && var.type != TOK_TOKCAT && !(var.type & TOK_ID))
912 {
913 s = pp.in->nextchr;
914 while ((c = *s++) && (c == ' ' || c == '\t'));
915 if (c == '\n')
916 c = 0;
917 else if (c == '*' && *s == ')')
918 c = ')';
919 else if (c == '=' || ppisidig(c) || c == *s || *s == '=')
920 c = 0;
921 if (o != '.' && o != T_PTRMEM)
922 {
923 if ((var.type & TOK_ID) || o == ' ' || ppisseparate(o))
924 o = 0;
925 if (!((o == 0 || o == '(' || o == ')' || o == '[' || o == ']' || o == ',' || o == '|' || o == ';' || o == '{' || o == '}') && (c == '(' || c == ')' || c == '[' || c == ']' || c == ',' || c == '|' || c == ';' || c == '}' || c == 0)) && !(o == '*' && c == ')'))
926 error(1, "%s: %s: formal should be parenthesized in macro value (t=%x o=%#c c=%#c)", sym->name, pp.token, var.type, o, c);
927 }
928 }
929 var.type = TOK_FORMAL|TOK_ID;
930 c = '>';
931 goto checkvalue;
932 }
933 if (var.type == TOK_BUILTIN) switch ((int)hashget(pp.strtab, pp.token))
934 {
935 case V_DEFAULT:
936 case V_EMPTY:
937 sym->flags |= SYM_EMPTY;
938 break;
939 }
940 else if (pp.hiding && (var.symbol = ppsymref(pp.symtab, pp.token)) && var.symbol->hidden)
941 {
942 for (var.inp = pp.in; var.inp->type != IN_FILE && var.inp->prev; var.inp = var.inp->prev);
943 p += sfsprintf(p, MAXTOKEN, "_%d_%s_hIDe", var.inp->hide, pp.token);
944 var.type = TOK_ID;
945 goto checkvalue;
946 }
947 var.type = TOK_ID;
948 break;
949 case '#':
950 var.type = 0;
951 #if MACDEF
952 if (!(sym->flags & (SYM_FUNCTION|SYM_MULTILINE))) break;
953 #else
954 if (!(sym->flags & SYM_FUNCTION)) break;
955 #endif
956 pp.state |= NOSPACE;
957 c = pplex();
958 if (c == '@')
959 {
960 c = pplex();
961 i4 = 'S';
962 }
963 else i4 = 'Q';
964 pp.state &= ~NOSPACE;
965 if (c != T_ID) c = mac->arity;
966 else for (c = 0; c < mac->arity; c++)
967 if (streq(formargs[c], pp.token))
968 break;
969 if (c >= mac->arity)
970 {
971 #if MACDEF
972 if (sym->flags & SYM_MULTILINE)
973 {
974 if (n3 & NEWLINE)
975 {
976 pp.state &= ~NOEXPAND;
977 switch ((int)hashref(pp.dirtab, pp.token))
978 {
979 case ENDMAC:
980 if (!i2--) goto gotdefinition;
981 break;
982 case INCLUDE:
983 /* PARSE HEADER constant */
984 break;
985 case MACDEF:
986 i2++;
987 break;
988 }
989 *p++ = '#';
990 }
991 }
992 else
993 #endif
994 #if COMPATIBLE
995 if (pp.state & COMPATIBILITY) *p++ = '#';
996 else
997 #endif
998 error(2, "# must precede a formal parameter");
999 }
1000 else
1001 {
1002 if (p > mac->value && ppisidig(*(p - 1)) && !(pp.option & PRESERVE)) *p++ = ' ';
1003 *p++ = MARK;
1004 *p++ = i4;
1005 *p++ = c + ARGOFFSET;
1006 goto checkvalue;
1007 }
1008 break;
1009 case T_TOKCAT:
1010 if (p <= mac->value) error(2, "%s lhs operand omitted", pp.token);
1011 else
1012 {
1013 if (*(p - 1) == ' ') p--;
1014 if (var.type == (TOK_FORMAL|TOK_ID)) *(p - 2) = 'C';
1015 }
1016 pp.state |= NOSPACE;
1017 c = pplex();
1018 pp.state &= ~NOSPACE;
1019 if (c == '\n') error(2, "%s rhs operand omitted", pptokchr(T_TOKCAT));
1020 var.type = TOK_TOKCAT;
1021 continue;
1022 case '(':
1023 if (*pp.token == '#')
1024 {
1025 var.type = TOK_BUILTIN;
1026 n1++;
1027 }
1028 else
1029 {
1030 var.type = 0;
1031 if (n1) n1++;
1032 }
1033 break;
1034 case ')':
1035 var.type = 0;
1036 if (n1) n1--;
1037 break;
1038 case T_STRING:
1039 case T_CHARCONST:
1040 pp.state &= ~NOEXPAND;
1041 var.type = 0;
1042 if (strchr(pp.token, MARK)) pp.state &= ~NOEXPAND;
1043 #if COMPATIBLE
1044 /*UNDENT*/
1045
1046 if ((sym->flags & SYM_FUNCTION) && (pp.state & (COMPATIBILITY|TRANSITION)))
1047 {
1048 char* v;
1049
1050 s = pp.token;
1051 for (;;)
1052 {
1053 if (!*s) goto checkvalue;
1054 if (ppisid(*s))
1055 {
1056 v = s;
1057 while (ppisid(*++s));
1058 i1 = *s;
1059 *s = 0;
1060 for (c = 0; c < mac->arity; c++)
1061 if (streq(formargs[c], v))
1062 {
1063 *p++ = MARK;
1064 *p++ = 'C';
1065 *p++ = c + ARGOFFSET;
1066 if (!(pp.mode & HOSTED) && (!(pp.state & COMPATIBILITY) || (pp.state & WARN))) switch (*pp.token)
1067 {
1068 case '"':
1069 error(1, "use the # operator to \"...\" quote macro arguments");
1070 break;
1071 case '\'':
1072 error(1, "macro arguments should be '...' quoted before substitution");
1073 break;
1074 }
1075 goto quotearg;
1076 }
1077 STRCOPY2(p, v);
1078 quotearg:
1079 *s = i1;
1080 }
1081 else *p++ = *s++;
1082 }
1083 }
1084 /*INDENT*/
1085 #endif
1086 break;
1087 case '\n':
1088 #if MACDEF
1089 if (sym->flags & SYM_MULTILINE)
1090 {
1091 if (pp.state & EOF2NL)
1092 {
1093 error_info.line++;
1094 pp.state |= HIDDEN;
1095 pp.hidden++;
1096 var.type = 0;
1097 if (!i3++)
1098 goto checkvalue;
1099 break;
1100 }
1101 pp.state |= EOF2NL;
1102 error(2, "%s: missing #%s", sym->name, dirname(ENDMAC));
1103 }
1104 #endif
1105 goto gotdefinition;
1106 case 0:
1107 c = '\n';
1108 goto gotdefinition;
1109 #if COMPATIBLE
1110 case ' ':
1111 if (pp.state & COMPATIBILITY) var.type = 0;
1112 if (pp.option & PRESERVE) break;
1113 if (p > mac->value && *(p - 1) != ' ') *p++ = ' ';
1114 goto checkvalue;
1115 case '\t':
1116 if (var.type & TOK_ID)
1117 {
1118 while ((c = pplex()) == '\t');
1119 if (c == T_ID)
1120 {
1121 if (var.type == (TOK_FORMAL|TOK_ID)) *(p - 2) = 'C';
1122 var.type = TOK_TOKCAT;
1123 if (pp.state & WARN) error(1, "use the ## operator to concatenate macro arguments");
1124 }
1125 else var.type = 0;
1126 continue;
1127 }
1128 var.type = 0;
1129 if (pp.option & PRESERVE) break;
1130 if (p > mac->value && *(p - 1) != ' ') *p++ = ' ';
1131 goto checkvalue;
1132 #endif
1133 case MARK:
1134 pp.state &= ~NOEXPAND;
1135 /*FALLTHROUGH*/
1136
1137 default:
1138 var.type = 0;
1139 break;
1140 }
1141 STRCOPY(p, pp.token, s);
1142 checkvalue:
1143 o = c;
1144 if (p > &mac->value[n - MAXTOKEN] && (s = newof(mac->value, char, n += MAXTOKEN, 0)) != mac->value)
1145 {
1146 c = p - mac->value;
1147 mac->value = s;
1148 p = mac->value + c;
1149 }
1150 #if MACDEF
1151 n3 = pp.state;
1152 #endif
1153 c = pplex();
1154 }
1155 gotdefinition:
1156 while (p > mac->value && *(p - 1) == ' ') p--;
1157 if (p > mac->value && (pp.option & PLUSPLUS) && (pp.state & (COMPATIBILITY|TRANSITION)) != COMPATIBILITY)
1158 switch (o)
1159 {
1160 case '+':
1161 case '-':
1162 case '&':
1163 case '|':
1164 case '<':
1165 case '>':
1166 case ':':
1167 case '=':
1168 *p++ = ' ';
1169 break;
1170 }
1171 *p = 0;
1172 #if MACKEYARGS
1173 if (!mac->arity) /* ok */;
1174 else if (pp.option & KEYARGS)
1175 {
1176 p0 = mac->formals;
1177 mac->formkeys = newof(0, struct ppkeyarg, n, p1 - p0 + 1);
1178 s = (char*)&mac->formkeys[mac->arity];
1179 (void)memcpy(s, p0, p1 - p0 + 1);
1180 free(p0);
1181 for (n = 0; n < mac->arity; n++)
1182 {
1183 mac->formkeys[n].name = s + (formargs[n] - p0);
1184 mac->formkeys[n].value = s + (formvals[n] - p0);
1185 }
1186 }
1187 else
1188 #endif
1189 for (n = 1; n < mac->arity; n++)
1190 *(formargs[n] - 1) = ',';
1191 if (old.value)
1192 {
1193 if ((i0 & SYM_FUNCTION) != (sym->flags & SYM_FUNCTION) || old.arity != mac->arity || !streq(old.value, mac->value)) goto redefined;
1194 if (!old.formals)
1195 {
1196 if (mac->formals) goto redefined;
1197 }
1198 else if (mac->formals)
1199 {
1200 #if MACKEYARGS
1201 if (pp.option & KEYARGS)
1202 {
1203 for (n = 0; n < mac->arity; n++)
1204 if (!streq(mac->formkeys[n].name, old.formkeys[n].name) || !streq(mac->formkeys[n].value, old.formkeys[n].value))
1205 goto redefined;
1206 }
1207 else
1208 #endif
1209 if (!streq(mac->formals, old.formals)) goto redefined;
1210 }
1211 #if MACKEYARGS
1212 if (pp.option & KEYARGS)
1213 {
1214 if (mac->formkeys) free(mac->formkeys);
1215 mac->formkeys = old.formkeys;
1216 }
1217 else
1218 #endif
1219 {
1220 if (mac->formals) free(mac->formals);
1221 mac->formals = old.formals;
1222 }
1223 free(mac->value);
1224 mac->value = old.value;
1225 goto benign;
1226 redefined:
1227 if (!(pp.mode & HOSTED) || !(i0 & SYM_INITIAL))
1228 error(1, "%s redefined", sym->name);
1229 #if MACKEYARGS
1230 if ((pp.option & KEYARGS) && mac->formkeys)
1231 free(mac->formkeys);
1232 #endif
1233 #if MACKEYARGS
1234 if (!(pp.option & KEYARGS))
1235 #endif
1236 if (old.formals) free(old.formals);
1237 free(old.value);
1238 }
1239 else if (!pp.truncate) ppfsm(FSM_MACRO, sym->name);
1240 mac->value = newof(mac->value, char, (mac->size = p - mac->value) + 1, 0);
1241 if ((pp.option & (DEFINITIONS|PREDEFINITIONS|REGUARD)) && !sym->hidden && !(sym->flags & SYM_MULTILINE) && ((pp.option & PREDEFINITIONS) || !(pp.mode & INIT)) && ((pp.option & (DEFINITIONS|PREDEFINITIONS)) || !(pp.state & NOTEXT)))
1242 {
1243 ppsync();
1244 ppprintf("#%s %s", dirname(DEFINE), sym->name);
1245 if (sym->flags & SYM_FUNCTION)
1246 {
1247 ppputchar('(');
1248 if (mac->formals)
1249 ppprintf("%s", mac->formals);
1250 ppputchar(')');
1251 }
1252 if ((p = mac->value) && *p)
1253 {
1254 ppputchar(' ');
1255 i0 = 0;
1256 while (n = *p++)
1257 {
1258 if (n != MARK || (n = *p++) == MARK)
1259 {
1260 ppputchar(n);
1261 i0 = ppisid(n);
1262 }
1263 else
1264 {
1265 if (n == 'Q')
1266 ppputchar('#');
1267 else if (i0)
1268 {
1269 ppputchar('#');
1270 ppputchar('#');
1271 }
1272 s = formargs[*p++ - ARGOFFSET];
1273 while ((n = *s++) && n != ',')
1274 ppputchar(n);
1275 if (ppisid(*p) || *p == MARK)
1276 {
1277 ppputchar('#');
1278 ppputchar('#');
1279 }
1280 i0 = 0;
1281 }
1282 ppcheckout();
1283 }
1284 }
1285 emitted = 1;
1286 }
1287 benign:
1288 if (pp.mode & BUILTIN) sym->flags |= SYM_BUILTIN;
1289 if (pp.option & FINAL) sym->flags |= SYM_FINAL;
1290 if (pp.mode & INIT) sym->flags |= SYM_INIT;
1291 if (pp.option & INITIAL) sym->flags |= SYM_INITIAL;
1292 if (pp.state & NOEXPAND) sym->flags |= SYM_NOEXPAND;
1293 if (pp.option & PREDEFINED) sym->flags |= SYM_PREDEFINED;
1294 if (pp.mode & READONLY) sym->flags |= SYM_READONLY;
1295 if (pp.macref) (*pp.macref)(sym, error_info.file, n2, mac ? error_info.line - n2 + 1 : REF_UNDEF, mac ? strsum(mac->value, (long)mac->arity) : 0L);
1296 break;
1297 assertion:
1298 c = pplex();
1299 if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
1300 error(1, "#%s #%s: assertions are non-standard", dirname(directive), pptokstr(pp.token, 0));
1301 if (c != T_ID)
1302 {
1303 error(2, "%s: invalid predicate name", pptokstr(pp.token, 0));
1304 goto eatdirective;
1305 }
1306 switch ((int)hashref(pp.strtab, pp.token))
1307 {
1308 case X_DEFINED:
1309 case X_EXISTS:
1310 case X_STRCMP:
1311 error(2, "%s is a builtin predicate", pp.token);
1312 goto eatdirective;
1313 case X_SIZEOF:
1314 error(2, "%s cannot be a predicate", pp.token);
1315 goto eatdirective;
1316 }
1317 strcpy(pp.tmpbuf, pp.token);
1318 switch (pppredargs())
1319 {
1320 case T_ID:
1321 case T_STRING:
1322 assert(directive, pp.tmpbuf, pp.args);
1323 break;
1324 case 0:
1325 assert(directive, pp.tmpbuf, NiL);
1326 break;
1327 default:
1328 error(2, "invalid predicate argument list");
1329 goto eatdirective;
1330 }
1331 break;
1332 tuple:
1333 pp.state |= DEFINITION|NOEXPAND|NOSPACE;
1334 rp = 0;
1335 tp = mac->tuple;
1336 if (!tp && !mac->value)
1337 ppfsm(FSM_MACRO, sym->name);
1338 while ((c = pplex()) && c != '>' && c != '\n')
1339 {
1340 for (; tp; tp = tp->nomatch)
1341 if (streq(tp->token, pp.token))
1342 break;
1343 if (!tp)
1344 {
1345 if (!(tp = newof(0, struct pptuple, 1, strlen(pp.token))))
1346 error(3, "out of space");
1347 strcpy(tp->token, pp.token);
1348 if (rp)
1349 {
1350 tp->nomatch = rp;
1351 rp->nomatch = tp;
1352 }
1353 else
1354 {
1355 tp->nomatch = mac->tuple;
1356 mac->tuple = tp;
1357 }
1358 }
1359 rp = tp;
1360 tp = tp->match;
1361 }
1362 pp.state &= ~NOSPACE;
1363 if (!rp || c != '>')
1364 error(2, "%s: > omitted in tuple macro definition", sym->name);
1365 else
1366 {
1367 n = 2 * MAXTOKEN;
1368 p = v = oldof(0, char, 0, n);
1369 while ((c = pplex()) && c != '\n')
1370 if (p > v || c != ' ')
1371 {
1372 STRCOPY(p, pp.token, s);
1373 if (p > &v[n - MAXTOKEN] && (s = newof(v, char, n += MAXTOKEN, 0)) != v)
1374 {
1375 c = p - v;
1376 v = s;
1377 p = v + c;
1378 }
1379 }
1380 while (p > v && *(p - 1) == ' ')
1381 p--;
1382 n = p - v;
1383 tp = newof(0, struct pptuple, 1, n);
1384 strcpy(tp->token, v);
1385 tp->match = rp->match;
1386 rp->match = tp;
1387 }
1388 goto benign;
1389 case WARNING:
1390 if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
1391 error(1, "#%s: non-standard directive", pp.token);
1392 /*FALLTHROUGH*/
1393 case ERROR:
1394 pp.state &= ~DISABLE;
1395 p = pp.tmpbuf;
1396 while ((c = pplex()) != '\n')
1397 if (p + strlen(pp.token) < &pp.tmpbuf[MAXTOKEN])
1398 {
1399 STRCOPY(p, pp.token, s);
1400 pp.state &= ~NOSPACE;
1401 }
1402 *p = 0;
1403 p = *pp.tmpbuf ? pp.tmpbuf : ((directive == WARNING) ? "user warning" : "user error");
1404 n = (directive == WARNING) ? 1 : 3;
1405 error(n, "%s", p);
1406 break;
1407 case LET:
1408 n2 = error_info.line;
1409 if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
1410 error(1, "#%s: non-standard directive", pp.token);
1411 if (!(sym = macsym(c = pplex()))) goto eatdirective;
1412 if ((c = pplex()) != '=')
1413 {
1414 error(2, "%s: = expected", sym->name);
1415 goto eatdirective;
1416 }
1417 sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_MULTILINE|SYM_PREDEFINED|SYM_VARIADIC);
1418 mac = sym->macro;
1419 mac->arity = 0;
1420 if (mac->value)
1421 {
1422 if (!(sym->flags & SYM_REDEFINE) && !sym->hidden)
1423 error(1, "%s: redefined", sym->name);
1424 #if MACKEYARGS
1425 if ((pp.option & KEYARGS) && mac->formkeys) free(mac->formkeys);
1426 else
1427 #endif
1428 free(mac->formals);
1429 mac->formals = 0;
1430 n = strlen(mac->value) + 1;
1431 }
1432 else
1433 {
1434 ppfsm(FSM_MACRO, sym->name);
1435 n = 0;
1436 }
1437 n1 = ppexpr(&i1);
1438 if (i1) c = sfsprintf(pp.tmpbuf, MAXTOKEN, "%luU", n1);
1439 else c = sfsprintf(pp.tmpbuf, MAXTOKEN, "%ld", n1);
1440 if (n < ++c)
1441 {
1442 if (mac->value) free(mac->value);
1443 mac->value = oldof(0, char, 0, c);
1444 }
1445 strcpy(mac->value, pp.tmpbuf);
1446 sym->flags |= SYM_REDEFINE;
1447 c = (pp.state & NEWLINE) ? '\n' : ' ';
1448 goto benign;
1449 case LINE:
1450 pp.state &= ~DISABLE;
1451 if ((c = pplex()) == '#')
1452 {
1453 c = pplex();
1454 directive = INCLUDE;
1455 }
1456 if (c != T_DECIMAL && c != T_OCTAL)
1457 {
1458 error(1, "#%s: line number expected", dirname(LINE));
1459 goto eatdirective;
1460 }
1461 linesync:
1462 n = error_info.line;
1463 error_info.line = strtol(pp.token, NiL, 0);
1464 if (error_info.line == 0 && directive == LINE && (pp.state & STRICT) && !(pp.mode & HOSTED))
1465 error(1, "#%s: line number should be > 0", dirname(LINE));
1466 pp.state &= ~DISABLE;
1467 pp.state |= STRIP;
1468 switch (c = pplex())
1469 {
1470 case T_STRING:
1471 s = error_info.file;
1472 if (*(p = pp.token))
1473 pathcanon(p, 0, 0);
1474 fp = ppsetfile(p);
1475 error_info.file = fp->name;
1476 if (error_info.line == 1)
1477 ppmultiple(fp, INC_IGNORE);
1478 switch (c = pplex())
1479 {
1480 case '\n':
1481 break;
1482 case T_DECIMAL:
1483 case T_OCTAL:
1484 if (directive == LINE && (pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
1485 error(1, "#%s: integer file type argument is non-standard", dirname(LINE));
1486 break;
1487 default:
1488 error(1, "#%s: integer file type argument expected", dirname(LINE));
1489 break;
1490 }
1491 if (directive == LINE) pp.in->flags &= ~IN_ignoreline;
1492 else if (pp.incref)
1493 {
1494 if (error_info.file != s)
1495 {
1496 switch (*pp.token)
1497 {
1498 case PP_sync_push:
1499 if (pp.insert) (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
1500 else (*pp.incref)(s, error_info.file, n, PP_SYNC_PUSH);
1501 break;
1502 case PP_sync_pop:
1503 if (pp.insert) (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
1504 else (*pp.incref)(s, error_info.file, n - 1, PP_SYNC_POP);
1505 break;
1506 case PP_sync_ignore:
1507 if (pp.insert) (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
1508 else
1509 {
1510 (*pp.incref)(s, error_info.file, n, PP_SYNC_IGNORE);
1511 error_info.file = s;
1512 }
1513 break;
1514 default:
1515 if (*s)
1516 {
1517 if (fp == pp.insert)
1518 pp.insert = 0;
1519 else if (error_info.line == 1 && !pp.insert)
1520 (*pp.incref)(s, error_info.file, n, PP_SYNC_PUSH);
1521 else
1522 {
1523 if (!pp.insert) pp.insert = ppgetfile(s);
1524 (*pp.incref)(s, error_info.file, n, PP_SYNC_INSERT);
1525 }
1526 }
1527 break;
1528 }
1529 }
1530 }
1531 break;
1532 case '\n':
1533 break;
1534 default:
1535 error(1, "#%s: \"file-name\" expected", dirname(LINE));
1536 break;
1537 }
1538 if (directive == LINE && (pp.in->flags & IN_ignoreline))
1539 error_info.line = n + 1;
1540 else
1541 {
1542 pp.hidden = 0;
1543 pp.state &= ~HIDDEN;
1544 if (pp.linesync)
1545 {
1546 #if CATSTRINGS
1547 if (pp.state & JOINING) pp.state |= HIDDEN|SYNCLINE;
1548 else
1549 #endif
1550 {
1551 s = pp.lineid;
1552 n = pp.flags;
1553 if (directive == LINE)
1554 {
1555 pp.flags &= ~PP_linetype;
1556 if (pp.macref) pp.lineid = dirname(LINE);
1557 }
1558 (*pp.linesync)(error_info.line, error_info.file);
1559 pp.flags = n;
1560 pp.lineid = s;
1561 }
1562 }
1563 }
1564 directive = LINE;
1565 break;
1566 case PRAGMA:
1567 /*
1568 * #pragma [STDC] [pass:] [no]option [arg ...]
1569 *
1570 * pragma args are not expanded by default
1571 *
1572 * if STDC is present then it is silently passed on
1573 *
1574 * if pass is pp.pass then the option is used
1575 * and verified but is not passed on
1576 *
1577 * if pass is omitted then the option is passed on
1578 *
1579 * otherwise if pass is non-null and not pp.pass then
1580 * the option is passed on but not used
1581 *
1582 * if the line does not match this form then
1583 * it is passed on unchanged
1584 *
1585 * #directive pass: option [...]
1586 * ^ ^ ^ ^ ^ ^ ^ ^
1587 * pp.valbuf p0 p1 p2 p3 p4 p5 p6
1588 *
1589 * p? 0 if component omitted
1590 * i0 0 if ``no''option
1591 */
1592
1593 p = pp.valbuf;
1594 *p++ = '#';
1595 STRCOPY(p, pp.token, s);
1596 p0 = p;
1597 if (pp.option & PRAGMAEXPAND)
1598 pp.state &= ~DISABLE;
1599 if (!(p6 = getline(p, &pp.valbuf[MAXTOKEN], !!(pp.option & PRAGMAEXPAND))))
1600 {
1601 *p0 = 0;
1602 error(2, "%s: directive too long", pp.valbuf);
1603 c = 0;
1604 goto eatdirective;
1605 }
1606 p1 = ++p;
1607 while (ppisid(*p))
1608 p++;
1609 if (p == p1)
1610 {
1611 p5 = p;
1612 p4 = 0;
1613 p3 = 0;
1614 p2 = 0;
1615 p1 = 0;
1616 }
1617 else if (*p != ':')
1618 {
1619 p5 = *p ? p + (*p == ' ') : 0;
1620 p4 = p;
1621 p3 = p1;
1622 p2 = 0;
1623 p1 = 0;
1624 }
1625 else
1626 {
1627 p2 = p++;
1628 p3 = p;
1629 while (ppisid(*p))
1630 p++;
1631 if (p == p3)
1632 {
1633 p4 = p1;
1634 p3 = 0;
1635 p2 = 0;
1636 p1 = 0;
1637 }
1638 else
1639 p4 = p;
1640 p5 = *p4 ? p4 + (*p4 == ' ') : 0;
1641 }
1642 if (!p1 && p3 && (p4 - p3) == 4 && strneq(p3, "STDC", 4))
1643 goto pass;
1644 if ((pp.state & WARN) && (pp.mode & (HOSTED|RELAX|PEDANTIC)) == PEDANTIC)
1645 error(1, "#%s: non-standard directive", dirname(PRAGMA));
1646 i0 = !p3 || *p3 != 'n' || *(p3 + 1) != 'o';
1647 if (!p3)
1648 goto checkmap;
1649 if (p1)
1650 {
1651 *p2 = 0;
1652 n = streq(p1, pp.pass);
1653 *p2 = ':';
1654 if (!n)
1655 goto checkmap;
1656 }
1657 else
1658 n = 0;
1659 i2 = *p4;
1660 *p4 = 0;
1661 if (((i1 = (int)hashref(pp.strtab, p3 + (i0 ? 0 : 2))) < 1 || i1 > X_last_option) && (i0 || (i1 = (int)hashref(pp.strtab, p3)) > X_last_option))
1662 i1 = 0;
1663 if ((pp.state & (COMPATIBILITY|STRICT)) == STRICT && !(pp.mode & (HOSTED|RELAX)))
1664 {
1665 if (pp.optflags[i1] & OPT_GLOBAL)
1666 goto donedirective;
1667 if (n || (pp.mode & WARN))
1668 {
1669 n = 0;
1670 error(1, "#%s: non-standard directive ignored", dirname(PRAGMA));
1671 }
1672 i1 = 0;
1673 }
1674 if (!n)
1675 {
1676 if (!(pp.optflags[i1] & OPT_GLOBAL))
1677 {
1678 *p4 = i2;
1679 goto checkmap;
1680 }
1681 if (!(pp.optflags[i1] & OPT_PASS))
1682 n = 1;
1683 }
1684 else if (!i1)
1685 error(2, "%s: unknown option", p1);
1686 else if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
1687 error(1, "%s: non-standard option", p1);
1688 p = p5;
1689 switch (i1)
1690 {
1691 case X_ALLMULTIPLE:
1692 ppop(PP_MULTIPLE, i0);
1693 break;
1694 case X_ALLPOSSIBLE:
1695 setoption(ALLPOSSIBLE, i0);
1696 break;
1697 case X_BUILTIN:
1698 setmode(BUILTIN, i0);
1699 break;
1700 case X_CATLITERAL:
1701 setmode(CATLITERAL, i0);
1702 if (pp.mode & CATLITERAL)
1703 setoption(STRINGSPLIT, 0);
1704 break;
1705 case X_CDIR:
1706 tokop(PP_CDIR, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
1707 break;
1708 case X_CHECKPOINT:
1709 #if CHECKPOINT
1710 ppload(p);
1711 #else
1712 error(3, "%s: preprocessor not compiled with checkpoint enabled", p3);
1713 #endif
1714 break;
1715 case X_CHOP:
1716 tokop(PP_CHOP, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
1717 break;
1718 case X_COMPATIBILITY:
1719 ppop(PP_COMPATIBILITY, i0);
1720 break;
1721 case X_DEBUG:
1722 error_info.trace = i0 ? (p ? -strtol(p, NiL, 0) : -1) : 0;
1723 break;
1724 case X_ELSEIF:
1725 setoption(ELSEIF, i0);
1726 break;
1727 case X_EXTERNALIZE:
1728 setmode(EXTERNALIZE, i0);
1729 break;
1730 case X_FINAL:
1731 setoption(FINAL, i0);
1732 break;
1733 case X_HEADEREXPAND:
1734 setoption(HEADEREXPAND, i0);
1735 break;
1736 case X_HEADEREXPANDALL:
1737 setoption(HEADEREXPANDALL, i0);
1738 break;
1739 case X_HIDE:
1740 case X_NOTE:
1741 PUSH_LINE(p);
1742 /* UNDENT...*/
1743 while (c = pplex())
1744 {
1745 if (c != T_ID) error(1, "%s: %s: identifier expected", p3, pp.token);
1746 else if (sym = ppsymset(pp.symtab, pp.token))
1747 {
1748 if (i1 == X_NOTE)
1749 {
1750 sym->flags &= ~SYM_NOTICED;
1751 ppfsm(FSM_MACRO, sym->name);
1752 }
1753 else if (i0)
1754 {
1755 if (!sym->hidden && !(sym->hidden = newof(0, struct pphide, 1, 0)))
1756 error(3, "out of space");
1757 if (!sym->macro)
1758 ppfsm(FSM_MACRO, sym->name);
1759 if (!sym->hidden->level++)
1760 {
1761 pp.hiding++;
1762 if (sym->macro && !(sym->flags & (SYM_ACTIVE|SYM_READONLY)))
1763 {
1764 sym->hidden->macro = sym->macro;
1765 sym->macro = 0;
1766 sym->hidden->flags = sym->flags;
1767 sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
1768 }
1769 }
1770 }
1771 else if (sym->hidden)
1772 {
1773 if ((mac = sym->macro) && !(sym->flags & (SYM_ACTIVE|SYM_READONLY)))
1774 {
1775 if (mac->formals) free(mac->formals);
1776 free(mac->value);
1777 free(mac);
1778 sym->macro = 0;
1779 sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
1780 }
1781 if (!--sym->hidden->level)
1782 {
1783 pp.hiding--;
1784 if (sym->hidden->macro)
1785 {
1786 sym->macro = sym->hidden->macro;
1787 sym->flags = sym->hidden->flags;
1788 }
1789 free(sym->hidden);
1790 sym->hidden = 0;
1791 }
1792 }
1793 }
1794 }
1795 /*...INDENT*/
1796 POP_LINE();
1797 break;
1798 case X_HOSTDIR:
1799 tokop(PP_HOSTDIR, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
1800 break;
1801 case X_HOSTED:
1802 setmode(HOSTED, i0);
1803 break;
1804 case X_HOSTEDTRANSITION:
1805 setmode(HOSTEDTRANSITION, i0);
1806 break;
1807 case X_ID:
1808 tokop(PP_ID, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
1809 break;
1810 case X_IGNORE:
1811 tokop(PP_IGNORE, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
1812 break;
1813 case X_INCLUDE:
1814 tokop(PP_INCLUDE, p3, p, i0, TOKOP_STRING|TOKOP_DUP);
1815 break;
1816 case X_INITIAL:
1817 setoption(INITIAL, i0);
1818 break;
1819 case X_KEYARGS:
1820 ppop(PP_KEYARGS, i0);
1821 break;
1822 case X_LINE:
1823 if (pp.linesync) pp.olinesync = pp.linesync;
1824 pp.linesync = i0 ? pp.olinesync : (PPLINESYNC)0;
1825 break;
1826 case X_LINEBASE:
1827 ppop(PP_LINEBASE, i0);
1828 break;
1829 case X_LINEFILE:
1830 ppop(PP_LINEFILE, i0);
1831 break;
1832 case X_LINEID:
1833 ppop(PP_LINEID, i0 ? p : (char*)0);
1834 break;
1835 case X_LINETYPE:
1836 ppop(PP_LINETYPE, i0 ? (p ? strtol(p, NiL, 0) : 1) : 0);
1837 break;
1838 case X_MACREF:
1839 if (!p)
1840 {
1841 if (i0 && !pp.macref)
1842 {
1843 ppop(PP_LINETYPE, 1);
1844 ppop(PP_MACREF, ppmacref);
1845 }
1846 else error(2, "%s: option cannot be unset", p3);
1847 }
1848 else if (s = strchr(p, ' '))
1849 {
1850 if (pp.macref && (s = strchr(p, ' ')))
1851 {
1852 *s++ = 0;
1853 c = strtol(s, NiL, 0);
1854 var.type = pp.truncate;
1855 pp.truncate = PPTOKSIZ;
1856 (*pp.macref)(pprefmac(p, REF_CREATE), error_info.file, error_info.line - (c == REF_NORMAL ? 2 : 1), c, (s = strchr(s, ' ')) ? strtol(s, NiL, 0) : 0L);
1857 pp.truncate = var.type;
1858 }
1859 error_info.line -= 2;
1860 }
1861 break;
1862 case X_MAP:
1863 /*UNDENT*/
1864 /*
1865 * #pragma pp:map [id ...] "/from/[,/to/]" [ "/old/new/[glnu]" ... ]
1866 */
1867
1868 if (!i0)
1869 {
1870 error(2, "%s: option cannot be unset", p3);
1871 goto donedirective;
1872 }
1873 if (!p5)
1874 {
1875 error(2, "%s: address argument expected", p3);
1876 goto donedirective;
1877 }
1878 PUSH_LINE(p5);
1879 while ((c = pplex()) == T_ID)
1880 {
1881 sfsprintf(pp.tmpbuf, MAXTOKEN, "__%s__", s = pp.token);
1882 if (c = (int)hashget(pp.dirtab, s))
1883 {
1884 hashput(pp.dirtab, 0, 0);
1885 hashput(pp.dirtab, pp.tmpbuf, c);
1886 }
1887 if (c = (int)hashget(pp.strtab, s))
1888 {
1889 hashput(pp.strtab, 0, 0);
1890 hashput(pp.strtab, pp.tmpbuf, c);
1891 }
1892 }
1893 if (c != T_STRING || !*(s = pp.token))
1894 {
1895 if (c)
1896 error(2, "%s: %s: address argument expected", p3, pptokstr(pp.token, 0));
1897 goto eatmap;
1898 }
1899 map = newof(0, struct map, 1, 0);
1900
1901 /*
1902 * /from/
1903 */
1904
1905 if (i0 = regcomp(&map->re, s, REG_AUGMENTED|REG_DELIMITED|REG_LENIENT|REG_NULL))
1906 regfatal(&map->re, 4, i0);
1907 if (*(s += map->re.re_npat))
1908 {
1909 error(2, "%s: invalid characters after pattern: %s ", p3, s);
1910 goto eatmap;
1911 }
1912
1913 /*
1914 * /old/new/[flags]
1915 */
1916
1917 edit = 0;
1918 while ((c = pplex()) == T_STRING)
1919 {
1920 if (!*(s = pp.token))
1921 {
1922 error(2, "%s: substitution argument expected", p3);
1923 goto eatmap;
1924 }
1925 if (edit)
1926 edit = edit->next = newof(0, struct edit, 1, 0);
1927 else
1928 edit = map->edit = newof(0, struct edit, 1, 0);
1929 if (!(i0 = regcomp(&edit->re, s, REG_AUGMENTED|REG_DELIMITED|REG_LENIENT|REG_NULL)) && !(i0 = regsubcomp(&edit->re, s += edit->re.re_npat, NiL, 0, 0)))
1930 s += edit->re.re_npat;
1931 if (i0)
1932 regfatal(&edit->re, 4, i0);
1933 if (*s)
1934 {
1935 error(2, "%s: invalid characters after substitution: %s ", p3, s);
1936 goto eatmap;
1937 }
1938 }
1939 if (c)
1940 {
1941 error(2, "%s: %s: substitution argument expected", p3, pptokstr(pp.token, 0));
1942 goto eatmap;
1943 }
1944 map->next = (struct map*)pp.maps;
1945 pp.maps = (char*)map;
1946 eatmap:
1947 POP_LINE();
1948 /*INDENT*/
1949 break;
1950 case X_MAPINCLUDE:
1951 ppmapinclude(NiL, p5);
1952 break;
1953 case X_MODERN:
1954 setoption(MODERN, i0);
1955 break;
1956 case X_MULTIPLE:
1957 n = 1;
1958 if (pp.in->type == IN_FILE || pp.in->type == IN_RESCAN)
1959 ppmultiple(ppsetfile(error_info.file), i0 ? INC_CLEAR : INC_IGNORE);
1960 break;
1961 case X_NATIVE:
1962 setoption(NATIVE, i0);
1963 break;
1964 case X_OPSPACE:
1965 ppfsm(FSM_OPSPACE, i0 ? p4 : (char*)0);
1966 break;
1967 case X_PASSTHROUGH:
1968 ppop(PP_PASSTHROUGH, i0);
1969 break;
1970 case X_PEDANTIC:
1971 ppop(PP_PEDANTIC, i0);
1972 break;
1973 case X_PLUSCOMMENT:
1974 ppop(PP_PLUSCOMMENT, i0);
1975 break;
1976 case X_PLUSPLUS:
1977 ppop(PP_PLUSPLUS, i0);
1978 break;
1979 case X_PLUSSPLICE:
1980 setoption(PLUSSPLICE, i0);
1981 break;
1982 case X_PRAGMAEXPAND:
1983 setoption(PRAGMAEXPAND, i0);
1984 break;
1985 case X_PRAGMAFLAGS:
1986 tokop(PP_PRAGMAFLAGS, p3, p, i0, 0);
1987 break;
1988 case X_PREDEFINED:
1989 setoption(PREDEFINED, i0);
1990 break;
1991 case X_PREFIX:
1992 setoption(PREFIX, i0);
1993 break;
1994 case X_PRESERVE:
1995 setoption(PRESERVE, i0);
1996 if (pp.option & PRESERVE)
1997 {
1998 setmode(CATLITERAL, 0);
1999 ppop(PP_COMPATIBILITY, 1);
2000 ppop(PP_TRANSITION, 0);
2001 ppop(PP_PLUSCOMMENT, 1);
2002 ppop(PP_SPACEOUT, 1);
2003 setoption(STRINGSPAN, 1);
2004 setoption(STRINGSPLIT, 0);
2005 ppop(PP_HOSTDIR, "-", 1);
2006 }
2007 break;
2008 case X_PROTOTYPED:
2009 /*
2010 * this option doesn't bump the token count
2011 */
2012
2013 n = 1;
2014 directive = ENDIF;
2015 #if PROTOTYPE
2016 setoption(PROTOTYPED, i0);
2017 #else
2018 error(1, "preprocessor not compiled with prototype conversion enabled");
2019 #endif
2020 break;
2021 case X_PROTO:
2022 setoption(NOPROTO, !i0);
2023 break;
2024 case X_QUOTE:
2025 tokop(PP_QUOTE, p3, p, i0, TOKOP_UNSET|TOKOP_STRING);
2026 break;
2027 case X_READONLY:
2028 setmode(READONLY, i0);
2029 break;
2030 case X_REGUARD:
2031 setoption(REGUARD, i0);
2032 break;
2033 case X_RESERVED:
2034 tokop(PP_RESERVED, p3, p, i0, 0);
2035 break;
2036 case X_SPACEOUT:
2037 if (!(pp.state & (COMPATIBILITY|COMPILE)))
2038 ppop(PP_SPACEOUT, i0);
2039 break;
2040 case X_SPLICECAT:
2041 setoption(SPLICECAT, i0);
2042 break;
2043 case X_SPLICESPACE:
2044 setoption(SPLICESPACE, i0);
2045 break;
2046 case X_STANDARD:
2047 tokop(PP_STANDARD, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
2048 break;
2049 case X_STRICT:
2050 ppop(PP_STRICT, i0);
2051 break;
2052 case X_STRINGSPAN:
2053 setoption(STRINGSPAN, i0);
2054 break;
2055 case X_STRINGSPLIT:
2056 setoption(STRINGSPLIT, i0);
2057 if (pp.option & STRINGSPLIT)
2058 setmode(CATLITERAL, 0);
2059 break;
2060 case X_SYSTEM_HEADER:
2061 if (i0)
2062 {
2063 pp.mode |= HOSTED;
2064 pp.flags |= PP_hosted;
2065 pp.in->flags |= IN_hosted;
2066 }
2067 else
2068 {
2069 pp.mode &= ~HOSTED;
2070 pp.flags &= ~PP_hosted;
2071 pp.in->flags &= ~PP_hosted;
2072 }
2073 break;
2074 case X_TEST:
2075 ppop(PP_TEST, p);
2076 break;
2077 case X_TEXT:
2078 if (!(pp.option & KEEPNOTEXT))
2079 setstate(NOTEXT, !i0);
2080 break;
2081 case X_TRANSITION:
2082 ppop(PP_TRANSITION, i0);
2083 if (pp.state & TRANSITION) ppop(PP_COMPATIBILITY, i0);
2084 break;
2085 case X_TRUNCATE:
2086 ppop(PP_TRUNCATE, i0 ? (p ? strtol(p, NiL, 0) : TRUNCLENGTH) : 0);
2087 break;
2088 case X_VENDOR:
2089 tokop(PP_VENDOR, p3, p, i0, TOKOP_UNSET|TOKOP_STRING|TOKOP_DUP);
2090 break;
2091 case X_VERSION:
2092 if (!(*pp.control & SKIP) && pp.pragma && !(pp.state & NOTEXT))
2093 {
2094 sfsprintf(pp.tmpbuf, MAXTOKEN, "\"%s\"", pp.version);
2095 (*pp.pragma)(dirname(PRAGMA), pp.pass, p3, pp.tmpbuf, !n);
2096 if (pp.linesync && !n)
2097 (*pp.linesync)(error_info.line, error_info.file);
2098 emitted = 1;
2099 }
2100 break;
2101 case X_WARN:
2102 ppop(PP_WARN, i0);
2103 break;
2104 case X_ZEOF:
2105 setoption(ZEOF, i0);
2106 break;
2107 #if DEBUG
2108 case 0:
2109 case X_INCLUDED:
2110 case X_NOTICED:
2111 case X_OPTION:
2112 case X_STATEMENT:
2113 break;
2114 default:
2115 error(PANIC, "%s: option recognized but not implemented", pp.valbuf);
2116 break;
2117 #endif
2118 }
2119 *p4 = i2;
2120 if (!n)
2121 goto checkmap;
2122 goto donedirective;
2123 case RENAME:
2124 if ((pp.state & STRICT) && !(pp.mode & (HOSTED|RELAX)))
2125 error(1, "#%s: non-standard directive", pp.token);
2126 if ((c = pplex()) != T_ID)
2127 {
2128 error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
2129 goto eatdirective;
2130 }
2131 if (!(sym = pprefmac(pp.token, REF_DELETE)) || !sym->macro)
2132 goto eatdirective;
2133 if (sym->flags & (SYM_ACTIVE|SYM_READONLY))
2134 {
2135 if (!(pp.option & ALLPOSSIBLE))
2136 error(2, "%s: macro is %s", sym->name, (sym->flags & SYM_READONLY) ? "readonly" : "active");
2137 goto eatdirective;
2138 }
2139 if ((c = pplex()) != T_ID)
2140 {
2141 error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
2142 goto eatdirective;
2143 }
2144 var.symbol = pprefmac(pp.token, REF_CREATE);
2145 if (mac = var.symbol->macro)
2146 {
2147 if (var.symbol->flags & (SYM_ACTIVE|SYM_READONLY))
2148 {
2149 if (!(pp.option & ALLPOSSIBLE))
2150 error(2, "%s: macro is %s", var.symbol->name, (var.symbol->flags & SYM_READONLY) ? "readonly" : "active");
2151 goto eatdirective;
2152 }
2153 if (!(pp.mode & HOSTED) || !(var.symbol->flags & SYM_INITIAL))
2154 error(1, "%s redefined", var.symbol->name);
2155 if (mac->formals) free(mac->formals);
2156 free(mac->value);
2157 free(mac);
2158 }
2159 ppfsm(FSM_MACRO, var.symbol->name);
2160 var.symbol->flags = sym->flags;
2161 sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
2162 var.symbol->macro = sym->macro;
2163 sym->macro = 0;
2164 break;
2165 case UNDEF:
2166 if ((c = pplex()) != T_ID)
2167 {
2168 error(1, "%s: invalid macro name", pptokstr(pp.token, 0));
2169 goto eatdirective;
2170 }
2171 if (sym = pprefmac(pp.token, REF_DELETE))
2172 {
2173 if (mac = sym->macro)
2174 {
2175 if (sym->flags & (SYM_ACTIVE|SYM_READONLY))
2176 {
2177 if (!(pp.option & ALLPOSSIBLE))
2178 error(2, "%s: macro is %s", sym->name, (sym->flags & SYM_READONLY) ? "readonly" : "active");
2179 goto eatdirective;
2180 }
2181 if (mac->formals) free(mac->formals);
2182 free(mac->value);
2183 free(mac);
2184 mac = sym->macro = 0;
2185 }
2186 if ((pp.option & (DEFINITIONS|PREDEFINITIONS|REGUARD)) && !sym->hidden && !(sym->flags & SYM_MULTILINE) && ((pp.option & PREDEFINITIONS) || !(pp.mode & INIT)) && ((pp.option & (DEFINITIONS|PREDEFINITIONS)) || !(pp.state & NOTEXT)))
2187 {
2188 ppsync();
2189 ppprintf("#%s %s", dirname(UNDEF), sym->name);
2190 emitted = 1;
2191 }
2192 sym->flags &= ~(SYM_BUILTIN|SYM_FUNCTION|SYM_INIT|SYM_MULTILINE|SYM_PREDEFINED|SYM_REDEFINE|SYM_VARIADIC);
2193 n2 = error_info.line;
2194 goto benign;
2195 }
2196 else pprefmac(pp.token, REF_UNDEF);
2197 break;
2198 #if DEBUG
2199 default:
2200 error(PANIC, "#%s: directive recognized but not implemented", pp.token);
2201 goto eatdirective;
2202 #endif
2203 }
2204 break;
2205 case '\n':
2206 break;
2207 default:
2208 error(1, "%s: invalid directive name", pptokstr(pp.token, 0));
2209 goto eatdirective;
2210 }
2211 enddirective:
2212 #if COMPATIBLE
2213 if (c != '\n' && !(pp.state & COMPATIBILITY))
2214 #else
2215 if (c != '\n')
2216 #endif
2217 {
2218 pp.state |= DISABLE|NOSPACE;
2219 if ((c = pplex()) != '\n' && (pp.mode & (HOSTED|PEDANTIC)) == PEDANTIC)
2220 error(1, "%s: invalid characters after directive", pptokstr(pp.token, 0));
2221 }
2222 eatdirective:
2223 if (c != '\n')
2224 {
2225 pp.state |= DISABLE;
2226 while (pplex() != '\n');
2227 }
2228 donedirective:
2229 #if _HUH_2002_05_09
2230 if (!(pp.state & EOF2NL))
2231 error(2, "%s in directive", pptokchr(0));
2232 #endif
2233 pp.state &= ~RESTORE;
2234 pp.mode &= ~RELAX;
2235 if (!(*pp.control & SKIP))
2236 {
2237 pp.state |= restore;
2238 switch (directive)
2239 {
2240 case LINE:
2241 return 0;
2242 case INCLUDE:
2243 if (pp.include)
2244 {
2245 error_info.line++;
2246 PUSH_FILE(pp.include, n);
2247 if (!pp.vendor && (pp.found->type & TYPE_VENDOR))
2248 pp.vendor = 1;
2249 pp.include = 0;
2250 return 0;
2251 }
2252 if (pp.incref)
2253 (*pp.incref)(error_info.file, ppgetfile(pp.path)->name, error_info.line, PP_SYNC_IGNORE);
2254 else if (pp.linesync && pp.macref)
2255 {
2256 pp.flags |= PP_lineignore;
2257 (*pp.linesync)(error_info.line, ppgetfile(pp.path)->name);
2258 }
2259 /*FALLTHROUGH*/
2260 default:
2261 pp.in->flags |= IN_tokens;
2262 /*FALLTHROUGH*/
2263 case ENDIF:
2264 error_info.line++;
2265 if (emitted)
2266 {
2267 ppputchar('\n');
2268 ppcheckout();
2269 }
2270 else
2271 {
2272 pp.state |= HIDDEN;
2273 pp.hidden++;
2274 }
2275 return 0;
2276 }
2277 }
2278 pp.state |= restore|HIDDEN|SKIPCONTROL;
2279 pp.hidden++;
2280 pp.level++;
2281 error_info.line++;
2282 return 0;
2283 }
2284
2285 /*
2286 * grow the pp nesting control stack
2287 */
2288
2289 void
ppnest(void)2290 ppnest(void)
2291 {
2292 register struct ppinstk* ip;
2293 int oz;
2294 int nz;
2295 long adjust;
2296 long* op;
2297 long* np;
2298
2299 oz = pp.constack;
2300 op = pp.maxcon - oz + 1;
2301 nz = oz * 2;
2302 np = newof(op, long, nz, 0);
2303 if (adjust = (np - op))
2304 {
2305 ip = pp.in;
2306 do
2307 {
2308 if (ip->control)
2309 ip->control += adjust;
2310 } while (ip = ip->prev);
2311 }
2312 pp.control = np + oz;
2313 pp.constack = nz;
2314 pp.maxcon = np + nz - 1;
2315 }
2316