?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libpp / common / ppexpr.c
blob225034b97df4a71d401cb6967a7f2867df3cd20d
1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1986-2009 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Common Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.opensource.org/licenses/cpl1.0.txt *
11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
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 expression evaluation support
26 */
27
28 #include "pplib.h"
29
30 #include <regex.h>
31
32 #define lex(c) ((((c)=peektoken)>=0?(peektoken=(-1)):((c)=pplex())),(c))
33 #define unlex(c) (peektoken=(c))
34
35 static int peektoken; /* expression lookahead token */
36 static char* errmsg; /* subexpr() error message */
37
38 /*
39 * exists predicate evaluation
40 */
41
42 static int
43 exists(int op, char* pred, register char* args)
44 {
45 register int c;
46 register int type;
47 char* pptoken;
48 long state;
49 char file[MAXTOKEN + 1];
50
51 state = (pp.state & ~DISABLE);
52 PUSH_STRING(args);
53 pptoken = pp.token;
54 pp.token = file;
55 pp.state |= HEADER|PASSEOF;
56 type = pplex();
57 pp.state &= ~HEADER;
58 pp.token = pptoken;
59 switch (type)
60 {
61 case T_STRING:
62 case T_HEADER:
63 break;
64 default:
65 error(1, "%s: \"...\" or <...> argument expected", pred);
66 c = 0;
67 goto done;
68 }
69 if (op == X_EXISTS)
70 {
71 if ((c = pplex()) == ',')
72 {
73 while ((c = pplex()) == T_STRING)
74 {
75 if (pathaccess(pp.path, pp.token, file, NiL, 0))
76 {
77 pathcanon(pp.path, 0);
78 message((-2, "%s: %s found", pred, pp.path));
79 c = 1;
80 goto done;
81 }
82 if ((c = pplex()) != ',') break;
83 }
84 if (c) error(1, "%s: \"...\" arguments expected", pred);
85 strcpy(pp.path, file);
86 message((-2, "%s: %s not found", pred, file));
87 c = 0;
88 }
89 else c = ppsearch(file, type, SEARCH_EXISTS) >= 0;
90 }
91 else
92 {
93 register struct ppfile* fp;
94
95 fp = ppsetfile(file);
96 c = fp->flags || fp->guard == INC_IGNORE;
97 }
98 done:
99 while (pplex());
100 pp.state = state;
101 return c;
102 }
103
104 /*
105 * strcmp/match predicate evaluation
106 */
107
108 static int
109 compare(char* pred, char* args, int match)
110 {
111 register int c;
112 char* pptoken;
113 long state;
114 regex_t re;
115 char tmp[MAXTOKEN + 1];
116
117 state = (pp.state & ~DISABLE);
118 PUSH_STRING(args);
119 pp.state |= PASSEOF;
120 pptoken = pp.token;
121 pp.token = tmp;
122 if (!pplex())
123 goto bad;
124 pp.token = pptoken;
125 if (pplex() != ',' || !pplex())
126 goto bad;
127 if (!match)
128 c = strcmp(tmp, pp.token);
129 else if ((c = regcomp(&re, pp.token, REG_AUGMENTED|REG_LENIENT|REG_NULL)) || (c = regexec(&re, tmp, NiL, 0, 0)) && c != REG_NOMATCH)
130 regfatal(&re, 3, c);
131 else
132 {
133 c = !c;
134 regfree(&re);
135 }
136 if ((pp.state & PASSEOF) && pplex())
137 goto bad;
138 pp.state = state;
139 return c;
140 bad:
141 pp.token = pptoken;
142 error(2, "%s: 2 arguments expected", pred);
143 while (pplex());
144 pp.state = state;
145 return 0;
146 }
147
148 /*
149 * #if predicate parse and evaluation
150 */
151
152 static int
153 predicate(int warn)
154 {
155 register char* args;
156 register struct pplist* p;
157 register struct ppsymbol* sym;
158 register int type;
159 int index;
160
161 static char pred[MAXID + 1];
162
163 /*
164 * first gather the args
165 */
166
167 index = (int)hashref(pp.strtab, pp.token);
168 if (warn && peekchr() != '(') switch (index)
169 {
170 case X_DEFINED:
171 case X_EXISTS:
172 case X_INCLUDED:
173 case X_MATCH:
174 case X_NOTICED:
175 case X_OPTION:
176 case X_SIZEOF:
177 case X_STRCMP:
178 break;
179 default:
180 if (pp.macref) pprefmac(pp.token, REF_IF);
181 return 0;
182 }
183 strcpy(pred, pp.token);
184 pp.state |= DISABLE;
185 type = pppredargs();
186 pp.state &= ~DISABLE;
187 switch (type)
188 {
189 case T_ID:
190 case T_STRING:
191 break;
192 default:
193 unlex(type);
194 /*FALLTHROUGH*/
195 case 0:
196 if (index && !(pp.state & STRICT))
197 error(1, "%s: predicate argument expected", pred);
198 if (pp.macref) pprefmac(pred, REF_IF);
199 return 0;
200 }
201 args = pp.args;
202
203 /*
204 * now evaluate
205 */
206
207 debug((-6, "pred=%s args=%s", pred, args));
208 if ((pp.state & STRICT) && !(pp.mode & HOSTED)) switch (index)
209 {
210 case X_DEFINED:
211 case X_SIZEOF:
212 break;
213 default:
214 error(1, "%s(%s): non-standard predicate test", pred, args);
215 return 0;
216 }
217 switch (index)
218 {
219 case X_DEFINED:
220 if (type != T_ID) error(1, "%s: identifier argument expected", pred);
221 else if ((sym = pprefmac(args, REF_IF)) && sym->macro) return 1;
222 else if (args[0] == '_' && args[1] == '_' && !strncmp(args, "__STDPP__", 9))
223 {
224 if (pp.hosted == 1 && pp.in->prev->type == IN_FILE)
225 {
226 pp.mode |= HOSTED;
227 pp.flags |= PP_hosted;
228 }
229 return *(args + 9) ? (int)hashref(pp.strtab, args + 9) : 1;
230 }
231 break;
232 case X_EXISTS:
233 case X_INCLUDED:
234 return exists(index, pred, args);
235 case X_MATCH:
236 case X_STRCMP:
237 return compare(pred, args, index == X_MATCH);
238 case X_NOTICED:
239 if (type != T_ID) error(1, "%s: identifier argument expected", pred);
240 else if (((sym = pprefmac(args, REF_IF)) || (sym = ppsymref(pp.symtab, args))) && (sym->flags & SYM_NOTICED)) return 1;
241 break;
242 case X_OPTION:
243 return ppoption(args);
244 case X_SIZEOF:
245 error(2, "%s invalid in #%s expressions", pred, dirname(IF));
246 break;
247 default:
248 if (warn && !(pp.mode & HOSTED) && (sym = ppsymref(pp.symtab, pred)) && (sym->flags & SYM_PREDICATE))
249 error(1, "use #%s(%s) to disambiguate", pred, args);
250 if (p = (struct pplist*)hashget(pp.prdtab, pred))
251 {
252 if (!*args) return 1;
253 while (p)
254 {
255 if (streq(p->value, args)) return 1;
256 p = p->next;
257 }
258 }
259 break;
260 }
261 return 0;
262 }
263
264 /*
265 * evaluate a long integer subexpression with precedence
266 * taken from the library routine streval()
267 * may be called recursively
268 *
269 * NOTE: all operands are evaluated as both the parse
270 * and evaluation are done on the fly
271 */
272
273 static long
274 subexpr(register int precedence, int* pun)
275 {
276 register int c;
277 register long n;
278 register long x;
279 register int operand = 1;
280 int un = 0;
281 int xn;
282
283 switch (lex(c))
284 {
285 case 0:
286 case '\n':
287 unlex(c);
288 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "more tokens expected";
289 return 0;
290 case '-':
291 n = -subexpr(13, &un);
292 break;
293 case '+':
294 n = subexpr(13, &un);
295 break;
296 case '!':
297 n = !subexpr(13, &un);
298 break;
299 case '~':
300 n = ~subexpr(13, &un);
301 break;
302 default:
303 unlex(c);
304 n = 0;
305 operand = 0;
306 break;
307 }
308 un <<= 1;
309 for (;;)
310 {
311 switch (lex(c))
312 {
313 case 0:
314 case '\n':
315 goto done;
316 case ')':
317 if (!precedence)
318 {
319 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "too many )'s";
320 return 0;
321 }
322 goto done;
323 case '(':
324 n = subexpr(1, &un);
325 if (lex(c) != ')')
326 {
327 unlex(c);
328 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "closing ) expected";
329 return 0;
330 }
331 gotoperand:
332 if (operand)
333 {
334 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "operator expected";
335 return 0;
336 }
337 operand = 1;
338 un <<= 1;
339 continue;
340 case '?':
341 if (precedence > 1) goto done;
342 un = 0;
343 if (lex(c) == ':')
344 {
345 if (!n) n = subexpr(2, &un);
346 else
347 {
348 x = pp.mode;
349 pp.mode |= INACTIVE;
350 subexpr(2, &xn);
351 pp.mode = x;
352 }
353 }
354 else
355 {
356 unlex(c);
357 x = subexpr(2, &xn);
358 if (lex(c) != ':')
359 {
360 unlex(c);
361 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = ": expected for ? operator";
362 return 0;
363 }
364 if (n)
365 {
366 n = x;
367 un = xn;
368 subexpr(2, &xn);
369 }
370 else n = subexpr(2, &un);
371 }
372 break;
373 case ':':
374 goto done;
375 case T_ANDAND:
376 case T_OROR:
377 xn = (c == T_ANDAND) ? 4 : 3;
378 if (precedence >= xn) goto done;
379 if ((n != 0) == (c == T_ANDAND)) n = subexpr(xn, &un) != 0;
380 else
381 {
382 x = pp.mode;
383 pp.mode |= INACTIVE;
384 subexpr(xn, &un);
385 pp.mode = x;
386 }
387 un = 0;
388 break;
389 case '|':
390 if (precedence > 4) goto done;
391 n |= subexpr(5, &un);
392 break;
393 case '^':
394 if (precedence > 5) goto done;
395 n ^= subexpr(6, &un);
396 break;
397 case '&':
398 if (precedence > 6) goto done;
399 n &= subexpr(7, &un);
400 break;
401 case T_EQ:
402 case T_NE:
403 if (precedence > 7) goto done;
404 n = (n == subexpr(8, &un)) == (c == T_EQ);
405 un = 0;
406 break;
407 case '<':
408 case T_LE:
409 case T_GE:
410 case '>':
411 if (precedence > 8) goto done;
412 x = subexpr(9, &un);
413 switch (c)
414 {
415 case '<':
416 switch (un)
417 {
418 case 01:
419 n = n < (unsigned long)x;
420 break;
421 case 02:
422 n = (unsigned long)n < x;
423 break;
424 case 03:
425 n = (unsigned long)n < (unsigned long)x;
426 break;
427 default:
428 n = n < x;
429 break;
430 }
431 break;
432 case T_LE:
433 switch (un)
434 {
435 case 01:
436 n = n <= (unsigned long)x;
437 break;
438 case 02:
439 n = (unsigned long)n <= x;
440 break;
441 case 03:
442 n = (unsigned long)n <= (unsigned long)x;
443 break;
444 default:
445 n = n <= x;
446 break;
447 }
448 break;
449 case T_GE:
450 switch (un)
451 {
452 case 01:
453 n = n >= (unsigned long)x;
454 break;
455 case 02:
456 n = (unsigned long)n >= x;
457 break;
458 case 03:
459 n = (unsigned long)n >= (unsigned long)x;
460 break;
461 default:
462 n = n >= x;
463 break;
464 }
465 break;
466 case '>':
467 switch (un)
468 {
469 case 01:
470 n = n > (unsigned long)x;
471 break;
472 case 02:
473 n = (unsigned long)n > x;
474 break;
475 case 03:
476 n = (unsigned long)n > (unsigned long)x;
477 break;
478 default:
479 n = n > x;
480 break;
481 }
482 break;
483 }
484 un = 0;
485 break;
486 case T_LSHIFT:
487 case T_RSHIFT:
488 if (precedence > 9) goto done;
489 x = subexpr(10, &un);
490 if (c == T_LSHIFT) n <<= x;
491 else n >>= x;
492 un >>= 1;
493 break;
494 case '+':
495 case '-':
496 if (precedence > 10) goto done;
497 x = subexpr(11, &un);
498 if (c == '+') n += x;
499 else n -= x;
500 break;
501 case '*':
502 case '/':
503 case '%':
504 if (precedence > 11) goto done;
505 x = subexpr(12, &un);
506 if (c == '*') n *= x;
507 else if (x == 0)
508 {
509 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "divide by zero";
510 return 0;
511 }
512 else if (c == '/') n /= x;
513 else n %= x;
514 break;
515 case '#':
516 pp.state |= DISABLE;
517 c = pplex();
518 pp.state &= ~DISABLE;
519 if (c != T_ID)
520 {
521 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "# must precede a predicate identifier";
522 return 0;
523 }
524 n = predicate(0);
525 goto gotoperand;
526 case T_ID:
527 n = predicate(1);
528 goto gotoperand;
529 case T_CHARCONST:
530 c = *(pp.toknxt - 1);
531 *(pp.toknxt - 1) = 0;
532 n = chrtoi(pp.token + 1);
533 *(pp.toknxt - 1) = c;
534 if (n & ~((1<<CHAR_BIT)-1))
535 {
536 if (!(pp.mode & HOSTED))
537 error(1, "'%s': multi-character character constants are not portable", pp.token);
538 }
539 #if CHAR_MIN < 0
540 else n = (char)n;
541 #endif
542 goto gotoperand;
543 case T_DECIMAL_U:
544 case T_DECIMAL_UL:
545 case T_OCTAL_U:
546 case T_OCTAL_UL:
547 case T_HEXADECIMAL_U:
548 case T_HEXADECIMAL_UL:
549 un |= 01;
550 /*FALLTHROUGH*/
551 case T_DECIMAL:
552 case T_DECIMAL_L:
553 case T_OCTAL:
554 case T_OCTAL_L:
555 case T_HEXADECIMAL:
556 case T_HEXADECIMAL_L:
557 n = strtoul(pp.token, NiL, 0);
558 if ((unsigned long)n > LONG_MAX) un |= 01;
559 goto gotoperand;
560 case T_WCHARCONST:
561 n = chrtoi(pp.token);
562 goto gotoperand;
563 default:
564 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "invalid token";
565 return 0;
566 }
567 if (errmsg) return 0;
568 if (!operand) goto nooperand;
569 }
570 done:
571 unlex(c);
572 if (!operand)
573 {
574 nooperand:
575 if (!errmsg && !(pp.mode & INACTIVE)) errmsg = "operand expected";
576 return 0;
577 }
578 if (un) *pun |= 01;
579 return n;
580 }
581
582 /*
583 * preprocessor expression evaluator using modified streval(3)
584 * *pun!=0 if result is unsigned
585 */
586
587 long
588 ppexpr(int* pun)
589 {
590 long n;
591 int opeektoken;
592 long ppstate;
593
594 ppstate = (pp.state & (CONDITIONAL|DISABLE|NOSPACE|STRIP));
595 pp.state &= ~(DISABLE|STRIP);
596 pp.state |= CONDITIONAL|NOSPACE;
597 opeektoken = peektoken;
598 peektoken = -1;
599 *pun = 0;
600 n = subexpr(0, pun);
601 if (peektoken == ':' && !errmsg && !(pp.mode & INACTIVE)) errmsg = "invalid use of :";
602 if (errmsg)
603 {
604 error(2, "%s in expression", errmsg);
605 errmsg = 0;
606 n = 0;
607 }
608 peektoken = opeektoken;
609 pp.state &= ~(CONDITIONAL|NOSPACE);
610 pp.state |= ppstate;
611 if (*pun) debug((-4, "ppexpr() = %luU", n));
612 else debug((-4, "ppexpr() = %ld", n));
613 return n;
614 }
615
616 /*
617 * return non-zero if option s is set
618 */
619
620 int
621 ppoption(char* s)
622 {
623 switch ((int)hashget(pp.strtab, s))
624 {
625 case X_ALLMULTIPLE:
626 return pp.mode & ALLMULTIPLE;
627 case X_BUILTIN:
628 return pp.mode & BUILTIN;
629 case X_CATLITERAL:
630 return pp.mode & CATLITERAL;
631 case X_COMPATIBILITY:
632 return pp.state & COMPATIBILITY;
633 case X_DEBUG:
634 return -error_info.trace;
635 case X_ELSEIF:
636 return pp.option & ELSEIF;
637 case X_FINAL:
638 return pp.option & FINAL;
639 case X_HOSTDIR:
640 return pp.mode & HOSTED;
641 case X_HOSTED:
642 return pp.flags & PP_hosted;
643 case X_INITIAL:
644 return pp.option & INITIAL;
645 case X_KEYARGS:
646 return pp.option & KEYARGS;
647 case X_LINEBASE:
648 return pp.flags & PP_linebase;
649 case X_LINEFILE:
650 return pp.flags & PP_linefile;
651 case X_LINETYPE:
652 return pp.flags & PP_linetype;
653 case X_PLUSCOMMENT:
654 return pp.option & PLUSCOMMENT;
655 case X_PLUSPLUS:
656 return pp.option & PLUSPLUS;
657 case X_PLUSSPLICE:
658 return pp.option & PLUSSPLICE;
659 case X_PRAGMAEXPAND:
660 return pp.option & PRAGMAEXPAND;
661 case X_PREDEFINED:
662 return pp.option & PREDEFINED;
663 case X_PREFIX:
664 return pp.option & PREFIX;
665 case X_PROTOTYPED:
666 return pp.option & PROTOTYPED;
667 case X_READONLY:
668 return pp.mode & READONLY;
669 case X_REGUARD:
670 return pp.option & REGUARD;
671 case X_SPACEOUT:
672 return pp.state & SPACEOUT;
673 case X_SPLICECAT:
674 return pp.option & SPLICECAT;
675 case X_SPLICESPACE:
676 return pp.option & SPLICESPACE;
677 case X_STRICT:
678 return pp.state & STRICT;
679 case X_STRINGSPAN:
680 return pp.option & STRINGSPAN;
681 case X_STRINGSPLIT:
682 return pp.option & STRINGSPLIT;
683 case X_TEST:
684 return pp.test;
685 case X_TEXT:
686 return !(pp.state & NOTEXT);
687 case X_TRANSITION:
688 return pp.state & TRANSITION;
689 case X_TRUNCATE:
690 return pp.truncate;
691 case X_WARN:
692 return pp.state & WARN;
693 default:
694 if (pp.state & WARN) error(1, "%s: unknown option name", s);
695 return 0;
696 }
697 }
unleashed repo fork