![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cexp.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cexp.y CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Parse C expressions for CCCP.
2: Copyright (C) 1987, 1992 Free Software Foundation.
3:
4: This program is free software; you can redistribute it and/or modify it
5: under the terms of the GNU General Public License as published by the
6: Free Software Foundation; either version 2, or (at your option) any
7: later version.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
17:
18: In other words, you are welcome to use, share and improve this program.
19: You are forbidden to forbid anyone else to use, share and improve
20: what you give them. Help stamp out software-hoarding!
21:
1.1.1.2 root 22: Adapted from expread.y of GDB by Paul Rubin, July 1986. */
1.1 root 23:
24: /* Parse a C expression from text in a string */
25:
26: %{
27: #include "config.h"
28: #include <setjmp.h>
29: /* #define YYDEBUG 1 */
30:
31: #ifdef MULTIBYTE_CHARS
32: #include <stdlib.h>
33: #include <locale.h>
34: #endif
35:
1.1.1.2 root 36: #include <stdio.h>
37:
1.1 root 38: typedef unsigned char U_CHAR;
39:
40: /* This is used for communicating lists of keywords with cccp.c. */
41: struct arglist {
42: struct arglist *next;
43: U_CHAR *name;
44: int length;
45: int argno;
46: };
47:
1.1.1.2 root 48: /* Define a generic NULL if one hasn't already been defined. */
49:
50: #ifndef NULL
51: #define NULL 0
52: #endif
53:
54: #ifndef GENERIC_PTR
55: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
56: #define GENERIC_PTR void *
57: #else
58: #define GENERIC_PTR char *
59: #endif
60: #endif
61:
62: #ifndef NULL_PTR
63: #define NULL_PTR ((GENERIC_PTR)0)
64: #endif
65:
1.1 root 66: int yylex ();
67: void yyerror ();
68: int expression_value;
69:
70: static jmp_buf parse_return_error;
71:
72: /* Nonzero means count most punctuation as part of a name. */
73: static int keyword_parsing = 0;
74:
75: /* some external tables of character types */
76: extern unsigned char is_idstart[], is_idchar[], is_hor_space[];
77:
1.1.1.2 root 78: extern char *xmalloc ();
79:
1.1 root 80: /* Flag for -pedantic. */
81: extern int pedantic;
82:
83: /* Flag for -traditional. */
84: extern int traditional;
85:
86: #ifndef CHAR_TYPE_SIZE
87: #define CHAR_TYPE_SIZE BITS_PER_UNIT
88: #endif
89:
90: #ifndef INT_TYPE_SIZE
91: #define INT_TYPE_SIZE BITS_PER_WORD
92: #endif
93:
94: #ifndef LONG_TYPE_SIZE
95: #define LONG_TYPE_SIZE BITS_PER_WORD
96: #endif
97:
98: #ifndef WCHAR_TYPE_SIZE
99: #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
100: #endif
1.1.1.2 root 101:
102: /* Yield nonzero if adding two numbers with A's and B's signs can yield a
103: number with SUM's sign, where A, B, and SUM are all C integers. */
104: #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
105:
106: static void integer_overflow ();
107: static long left_shift ();
108: static long right_shift ();
1.1 root 109: %}
110:
111: %union {
112: struct constant {long value; int unsignedp;} integer;
113: struct name {U_CHAR *address; int length;} name;
114: struct arglist *keywords;
115: int voidval;
116: char *sval;
117: }
118:
119: %type <integer> exp exp1 start
120: %type <keywords> keywords
121: %token <integer> INT CHAR
122: %token <name> NAME
123: %token <integer> ERROR
124:
125: %right '?' ':'
126: %left ','
127: %left OR
128: %left AND
129: %left '|'
130: %left '^'
131: %left '&'
132: %left EQUAL NOTEQUAL
133: %left '<' '>' LEQ GEQ
134: %left LSH RSH
135: %left '+' '-'
136: %left '*' '/' '%'
137: %right UNARY
138:
139: /* %expect 40 */
140:
141: %%
142:
143: start : exp1
144: { expression_value = $1.value; }
145: ;
146:
147: /* Expressions, including the comma operator. */
148: exp1 : exp
149: | exp1 ',' exp
150: { if (pedantic)
151: pedwarn ("comma operator in operand of `#if'");
152: $$ = $3; }
153: ;
154:
155: /* Expressions, not including the comma operator. */
156: exp : '-' exp %prec UNARY
157: { $$.value = - $2.value;
1.1.1.2 root 158: if (($$.value & $2.value) < 0 && ! $2.unsignedp)
159: integer_overflow ();
1.1 root 160: $$.unsignedp = $2.unsignedp; }
161: | '!' exp %prec UNARY
162: { $$.value = ! $2.value;
163: $$.unsignedp = 0; }
164: | '+' exp %prec UNARY
165: { $$ = $2; }
166: | '~' exp %prec UNARY
167: { $$.value = ~ $2.value;
168: $$.unsignedp = $2.unsignedp; }
169: | '#' NAME
170: { $$.value = check_assertion ($2.address, $2.length,
1.1.1.2 root 171: 0, NULL_PTR);
1.1 root 172: $$.unsignedp = 0; }
173: | '#' NAME
174: { keyword_parsing = 1; }
175: '(' keywords ')'
176: { $$.value = check_assertion ($2.address, $2.length,
177: 1, $5);
178: keyword_parsing = 0;
179: $$.unsignedp = 0; }
180: | '(' exp1 ')'
181: { $$ = $2; }
182: ;
183:
184: /* Binary operators in order of decreasing precedence. */
185: exp : exp '*' exp
186: { $$.unsignedp = $1.unsignedp || $3.unsignedp;
187: if ($$.unsignedp)
1.1.1.2 root 188: $$.value = (unsigned long) $1.value * $3.value;
1.1 root 189: else
1.1.1.2 root 190: {
191: $$.value = $1.value * $3.value;
192: if ($1.value
193: && ($$.value / $1.value != $3.value
194: || ($$.value & $1.value & $3.value) < 0))
195: integer_overflow ();
196: } }
1.1 root 197: | exp '/' exp
198: { if ($3.value == 0)
199: {
200: error ("division by zero in #if");
201: $3.value = 1;
202: }
203: $$.unsignedp = $1.unsignedp || $3.unsignedp;
204: if ($$.unsignedp)
1.1.1.2 root 205: $$.value = (unsigned long) $1.value / $3.value;
1.1 root 206: else
1.1.1.2 root 207: {
208: $$.value = $1.value / $3.value;
209: if (($$.value & $1.value & $3.value) < 0)
210: integer_overflow ();
211: } }
1.1 root 212: | exp '%' exp
213: { if ($3.value == 0)
214: {
215: error ("division by zero in #if");
216: $3.value = 1;
217: }
218: $$.unsignedp = $1.unsignedp || $3.unsignedp;
219: if ($$.unsignedp)
1.1.1.2 root 220: $$.value = (unsigned long) $1.value % $3.value;
1.1 root 221: else
222: $$.value = $1.value % $3.value; }
223: | exp '+' exp
224: { $$.value = $1.value + $3.value;
1.1.1.2 root 225: $$.unsignedp = $1.unsignedp || $3.unsignedp;
226: if (! $$.unsignedp
227: && ! possible_sum_sign ($1.value, $3.value,
228: $$.value))
229: integer_overflow (); }
1.1 root 230: | exp '-' exp
231: { $$.value = $1.value - $3.value;
1.1.1.2 root 232: $$.unsignedp = $1.unsignedp || $3.unsignedp;
233: if (! $$.unsignedp
234: && ! possible_sum_sign ($$.value, $3.value,
235: $1.value))
236: integer_overflow (); }
1.1 root 237: | exp LSH exp
238: { $$.unsignedp = $1.unsignedp;
1.1.1.2 root 239: if ($3.value < 0 && ! $3.unsignedp)
240: $$.value = right_shift (&$1, -$3.value);
1.1 root 241: else
1.1.1.2 root 242: $$.value = left_shift (&$1, $3.value); }
1.1 root 243: | exp RSH exp
244: { $$.unsignedp = $1.unsignedp;
1.1.1.2 root 245: if ($3.value < 0 && ! $3.unsignedp)
246: $$.value = left_shift (&$1, -$3.value);
1.1 root 247: else
1.1.1.2 root 248: $$.value = right_shift (&$1, $3.value); }
1.1 root 249: | exp EQUAL exp
250: { $$.value = ($1.value == $3.value);
251: $$.unsignedp = 0; }
252: | exp NOTEQUAL exp
253: { $$.value = ($1.value != $3.value);
254: $$.unsignedp = 0; }
255: | exp LEQ exp
256: { $$.unsignedp = 0;
257: if ($1.unsignedp || $3.unsignedp)
1.1.1.2 root 258: $$.value = (unsigned long) $1.value <= $3.value;
1.1 root 259: else
260: $$.value = $1.value <= $3.value; }
261: | exp GEQ exp
262: { $$.unsignedp = 0;
263: if ($1.unsignedp || $3.unsignedp)
1.1.1.2 root 264: $$.value = (unsigned long) $1.value >= $3.value;
1.1 root 265: else
266: $$.value = $1.value >= $3.value; }
267: | exp '<' exp
268: { $$.unsignedp = 0;
269: if ($1.unsignedp || $3.unsignedp)
1.1.1.2 root 270: $$.value = (unsigned long) $1.value < $3.value;
1.1 root 271: else
272: $$.value = $1.value < $3.value; }
273: | exp '>' exp
274: { $$.unsignedp = 0;
275: if ($1.unsignedp || $3.unsignedp)
1.1.1.2 root 276: $$.value = (unsigned long) $1.value > $3.value;
1.1 root 277: else
278: $$.value = $1.value > $3.value; }
279: | exp '&' exp
280: { $$.value = $1.value & $3.value;
281: $$.unsignedp = $1.unsignedp || $3.unsignedp; }
282: | exp '^' exp
283: { $$.value = $1.value ^ $3.value;
284: $$.unsignedp = $1.unsignedp || $3.unsignedp; }
285: | exp '|' exp
286: { $$.value = $1.value | $3.value;
287: $$.unsignedp = $1.unsignedp || $3.unsignedp; }
288: | exp AND exp
289: { $$.value = ($1.value && $3.value);
290: $$.unsignedp = 0; }
291: | exp OR exp
292: { $$.value = ($1.value || $3.value);
293: $$.unsignedp = 0; }
294: | exp '?' exp ':' exp
295: { $$.value = $1.value ? $3.value : $5.value;
296: $$.unsignedp = $3.unsignedp || $5.unsignedp; }
297: | INT
298: { $$ = yylval.integer; }
299: | CHAR
300: { $$ = yylval.integer; }
301: | NAME
302: { $$.value = 0;
303: $$.unsignedp = 0; }
304: ;
305:
306: keywords :
307: { $$ = 0; }
308: | '(' keywords ')' keywords
309: { struct arglist *temp;
310: $$ = (struct arglist *) xmalloc (sizeof (struct arglist));
311: $$->next = $2;
312: $$->name = (U_CHAR *) "(";
313: $$->length = 1;
314: temp = $$;
315: while (temp != 0 && temp->next != 0)
316: temp = temp->next;
317: temp->next = (struct arglist *) xmalloc (sizeof (struct arglist));
318: temp->next->next = $4;
319: temp->next->name = (U_CHAR *) ")";
320: temp->next->length = 1; }
321: | NAME keywords
322: { $$ = (struct arglist *) xmalloc (sizeof (struct arglist));
323: $$->name = $1.address;
324: $$->length = $1.length;
325: $$->next = $2; }
326: ;
327: %%
328:
329: /* During parsing of a C expression, the pointer to the next character
330: is in this variable. */
331:
332: static char *lexptr;
333:
334: /* Take care of parsing a number (anything that starts with a digit).
335: Set yylval and return the token type; update lexptr.
336: LEN is the number of characters in it. */
337:
338: /* maybe needs to actually deal with floating point numbers */
339:
340: int
341: parse_number (olen)
342: int olen;
343: {
344: register char *p = lexptr;
345: register int c;
1.1.1.2 root 346: register unsigned long n = 0, nd, ULONG_MAX_over_base;
1.1 root 347: register int base = 10;
348: register int len = olen;
1.1.1.2 root 349: register int overflow = 0;
350: register int digit, largest_digit = 0;
351: int spec_long = 0;
1.1 root 352:
353: for (c = 0; c < len; c++)
354: if (p[c] == '.') {
355: /* It's a float since it contains a point. */
356: yyerror ("floating point numbers not allowed in #if expressions");
357: return ERROR;
358: }
359:
360: yylval.integer.unsignedp = 0;
361:
362: if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
363: p += 2;
364: base = 16;
365: len -= 2;
366: }
367: else if (*p == '0')
368: base = 8;
369:
1.1.1.2 root 370: ULONG_MAX_over_base = (unsigned long) -1 / base;
371:
372: for (; len > 0; len--) {
1.1 root 373: c = *p++;
374:
1.1.1.2 root 375: if (c >= '0' && c <= '9')
376: digit = c - '0';
377: else if (base == 16 && c >= 'a' && c <= 'f')
378: digit = c - 'a' + 10;
379: else if (base == 16 && c >= 'A' && c <= 'F')
380: digit = c - 'A' + 10;
381: else {
1.1 root 382: /* `l' means long, and `u' means unsigned. */
383: while (1) {
384: if (c == 'l' || c == 'L')
1.1.1.2 root 385: {
386: if (spec_long)
387: yyerror ("two `l's in integer constant");
388: spec_long = 1;
389: }
1.1 root 390: else if (c == 'u' || c == 'U')
1.1.1.2 root 391: {
392: if (yylval.integer.unsignedp)
393: yyerror ("two `u's in integer constant");
394: yylval.integer.unsignedp = 1;
395: }
1.1 root 396: else
397: break;
398:
1.1.1.2 root 399: if (--len == 0)
1.1 root 400: break;
401: c = *p++;
402: }
403: /* Don't look for any more digits after the suffixes. */
404: break;
405: }
1.1.1.2 root 406: if (largest_digit < digit)
407: largest_digit = digit;
408: nd = n * base + digit;
409: overflow |= ULONG_MAX_over_base < n | nd < n;
410: n = nd;
1.1 root 411: }
412:
413: if (len != 0) {
414: yyerror ("Invalid number in #if expression");
415: return ERROR;
416: }
417:
1.1.1.2 root 418: if (base <= largest_digit)
419: warning ("integer constant contains digits beyond the radix");
420:
421: if (overflow)
422: warning ("integer constant out of range");
423:
1.1 root 424: /* If too big to be signed, consider it unsigned. */
1.1.1.2 root 425: if ((long) n < 0 && ! yylval.integer.unsignedp)
426: {
427: if (base == 10)
428: warning ("integer constant is so large that it is unsigned");
429: yylval.integer.unsignedp = 1;
430: }
1.1 root 431:
432: lexptr = p;
433: yylval.integer.value = n;
434: return INT;
435: }
436:
437: struct token {
438: char *operator;
439: int token;
440: };
441:
442: static struct token tokentab2[] = {
443: {"&&", AND},
444: {"||", OR},
445: {"<<", LSH},
446: {">>", RSH},
447: {"==", EQUAL},
448: {"!=", NOTEQUAL},
449: {"<=", LEQ},
450: {">=", GEQ},
451: {"++", ERROR},
452: {"--", ERROR},
453: {NULL, ERROR}
454: };
455:
456: /* Read one token, getting characters through lexptr. */
457:
458: int
459: yylex ()
460: {
461: register int c;
462: register int namelen;
1.1.1.3 ! root 463: register unsigned char *tokstart;
1.1 root 464: register struct token *toktab;
465: int wide_flag;
466:
467: retry:
468:
1.1.1.3 ! root 469: tokstart = (unsigned char *) lexptr;
1.1 root 470: c = *tokstart;
471: /* See if it is a special token of length 2. */
472: if (! keyword_parsing)
473: for (toktab = tokentab2; toktab->operator != NULL; toktab++)
474: if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
475: lexptr += 2;
476: if (toktab->token == ERROR)
477: {
478: char *buf = (char *) alloca (40);
479: sprintf (buf, "`%s' not allowed in operand of `#if'", toktab->operator);
480: yyerror (buf);
481: }
482: return toktab->token;
483: }
484:
485: switch (c) {
486: case 0:
487: return 0;
488:
489: case ' ':
490: case '\t':
491: case '\r':
492: case '\n':
493: lexptr++;
494: goto retry;
495:
496: case 'L':
497: /* Capital L may start a wide-string or wide-character constant. */
498: if (lexptr[1] == '\'')
499: {
500: lexptr++;
501: wide_flag = 1;
502: goto char_constant;
503: }
504: if (lexptr[1] == '"')
505: {
506: lexptr++;
507: wide_flag = 1;
508: goto string_constant;
509: }
510: break;
511:
512: case '\'':
513: wide_flag = 0;
514: char_constant:
515: lexptr++;
516: if (keyword_parsing) {
517: char *start_ptr = lexptr - 1;
518: while (1) {
519: c = *lexptr++;
520: if (c == '\\')
521: c = parse_escape (&lexptr);
522: else if (c == '\'')
523: break;
524: }
1.1.1.3 ! root 525: yylval.name.address = tokstart;
1.1 root 526: yylval.name.length = lexptr - start_ptr;
527: return NAME;
528: }
529:
530: /* This code for reading a character constant
531: handles multicharacter constants and wide characters.
532: It is mostly copied from c-lex.c. */
533: {
534: register int result = 0;
535: register num_chars = 0;
536: unsigned width = CHAR_TYPE_SIZE;
537: int max_chars;
538: char *token_buffer;
539:
540: if (wide_flag)
541: {
542: width = WCHAR_TYPE_SIZE;
543: #ifdef MULTIBYTE_CHARS
544: max_chars = MB_CUR_MAX;
545: #else
546: max_chars = 1;
547: #endif
548: }
549: else
550: max_chars = LONG_TYPE_SIZE / width;
551:
552: token_buffer = (char *) alloca (max_chars + 1);
553:
554: while (1)
555: {
556: c = *lexptr++;
557:
558: if (c == '\'' || c == EOF)
559: break;
560:
561: if (c == '\\')
562: {
563: c = parse_escape (&lexptr);
564: if (width < HOST_BITS_PER_INT
565: && (unsigned) c >= (1 << width))
566: pedwarn ("escape sequence out of range for character");
567: }
568:
569: num_chars++;
570:
571: /* Merge character into result; ignore excess chars. */
572: if (num_chars < max_chars + 1)
573: {
574: if (width < HOST_BITS_PER_INT)
575: result = (result << width) | (c & ((1 << width) - 1));
576: else
577: result = c;
578: token_buffer[num_chars - 1] = c;
579: }
580: }
581:
582: token_buffer[num_chars] = 0;
583:
584: if (c != '\'')
585: error ("malformatted character constant");
586: else if (num_chars == 0)
587: error ("empty character constant");
588: else if (num_chars > max_chars)
589: {
590: num_chars = max_chars;
591: error ("character constant too long");
592: }
593: else if (num_chars != 1 && ! traditional)
594: warning ("multi-character character constant");
595:
596: /* If char type is signed, sign-extend the constant. */
597: if (! wide_flag)
598: {
599: int num_bits = num_chars * width;
600:
601: if (lookup ("__CHAR_UNSIGNED__", sizeof ("__CHAR_UNSIGNED__")-1, -1)
602: || ((result >> (num_bits - 1)) & 1) == 0)
603: yylval.integer.value
1.1.1.2 root 604: = result & ((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
1.1 root 605: else
606: yylval.integer.value
1.1.1.2 root 607: = result | ~((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
1.1 root 608: }
609: else
610: {
611: #ifdef MULTIBYTE_CHARS
612: /* Set the initial shift state and convert the next sequence. */
613: result = 0;
614: /* In all locales L'\0' is zero and mbtowc will return zero,
615: so don't use it. */
616: if (num_chars > 1
617: || (num_chars == 1 && token_buffer[0] != '\0'))
618: {
619: wchar_t wc;
1.1.1.2 root 620: (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1.1 root 621: if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
622: result = wc;
623: else
624: warning ("Ignoring invalid multibyte character");
625: }
626: #endif
627: yylval.integer.value = result;
628: }
629: }
630:
631: /* This is always a signed type. */
632: yylval.integer.unsignedp = 0;
633:
634: return CHAR;
635:
636: /* some of these chars are invalid in constant expressions;
637: maybe do something about them later */
638: case '/':
639: case '+':
640: case '-':
641: case '*':
642: case '%':
643: case '|':
644: case '&':
645: case '^':
646: case '~':
647: case '!':
648: case '@':
649: case '<':
650: case '>':
651: case '[':
652: case ']':
653: case '.':
654: case '?':
655: case ':':
656: case '=':
657: case '{':
658: case '}':
659: case ',':
660: case '#':
661: if (keyword_parsing)
662: break;
663: case '(':
664: case ')':
665: lexptr++;
666: return c;
667:
668: case '"':
669: string_constant:
670: if (keyword_parsing) {
671: char *start_ptr = lexptr;
672: lexptr++;
673: while (1) {
674: c = *lexptr++;
675: if (c == '\\')
676: c = parse_escape (&lexptr);
677: else if (c == '"')
678: break;
679: }
1.1.1.3 ! root 680: yylval.name.address = tokstart;
1.1 root 681: yylval.name.length = lexptr - start_ptr;
682: return NAME;
683: }
684: yyerror ("string constants not allowed in #if expressions");
685: return ERROR;
686: }
687:
688: if (c >= '0' && c <= '9' && !keyword_parsing) {
689: /* It's a number */
690: for (namelen = 0;
691: c = tokstart[namelen], is_idchar[c] || c == '.';
692: namelen++)
693: ;
694: return parse_number (namelen);
695: }
696:
697: /* It is a name. See how long it is. */
698:
699: if (keyword_parsing) {
700: for (namelen = 0;; namelen++) {
701: if (is_hor_space[tokstart[namelen]])
702: break;
703: if (tokstart[namelen] == '(' || tokstart[namelen] == ')')
704: break;
705: if (tokstart[namelen] == '"' || tokstart[namelen] == '\'')
706: break;
707: }
708: } else {
709: if (!is_idstart[c]) {
710: yyerror ("Invalid token in expression");
711: return ERROR;
712: }
713:
714: for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
715: ;
716: }
717:
718: lexptr += namelen;
1.1.1.3 ! root 719: yylval.name.address = tokstart;
1.1 root 720: yylval.name.length = namelen;
721: return NAME;
722: }
723:
724:
725: /* Parse a C escape sequence. STRING_PTR points to a variable
726: containing a pointer to the string to parse. That pointer
727: is updated past the characters we use. The value of the
728: escape sequence is returned.
729:
730: A negative value means the sequence \ newline was seen,
731: which is supposed to be equivalent to nothing at all.
732:
733: If \ is followed by a null character, we return a negative
734: value and leave the string pointer pointing at the null character.
735:
736: If \ is followed by 000, we return 0 and leave the string pointer
737: after the zeros. A value of 0 does not mean end of string. */
738:
739: int
740: parse_escape (string_ptr)
741: char **string_ptr;
742: {
743: register int c = *(*string_ptr)++;
744: switch (c)
745: {
746: case 'a':
747: return TARGET_BELL;
748: case 'b':
749: return TARGET_BS;
750: case 'e':
1.1.1.3 ! root 751: case 'E':
! 752: if (pedantic)
! 753: pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
1.1 root 754: return 033;
755: case 'f':
756: return TARGET_FF;
757: case 'n':
758: return TARGET_NEWLINE;
759: case 'r':
760: return TARGET_CR;
761: case 't':
762: return TARGET_TAB;
763: case 'v':
764: return TARGET_VT;
765: case '\n':
766: return -2;
767: case 0:
768: (*string_ptr)--;
769: return 0;
770:
771: case '0':
772: case '1':
773: case '2':
774: case '3':
775: case '4':
776: case '5':
777: case '6':
778: case '7':
779: {
780: register int i = c - '0';
781: register int count = 0;
782: while (++count < 3)
783: {
784: c = *(*string_ptr)++;
785: if (c >= '0' && c <= '7')
786: i = (i << 3) + c - '0';
787: else
788: {
789: (*string_ptr)--;
790: break;
791: }
792: }
793: if ((i & ~((1 << CHAR_TYPE_SIZE) - 1)) != 0)
794: {
795: i &= (1 << CHAR_TYPE_SIZE) - 1;
796: warning ("octal character constant does not fit in a byte");
797: }
798: return i;
799: }
800: case 'x':
801: {
1.1.1.2 root 802: register unsigned i = 0, overflow = 0, digits_found = 0, digit;
1.1 root 803: for (;;)
804: {
805: c = *(*string_ptr)++;
806: if (c >= '0' && c <= '9')
1.1.1.2 root 807: digit = c - '0';
1.1 root 808: else if (c >= 'a' && c <= 'f')
1.1.1.2 root 809: digit = c - 'a' + 10;
1.1 root 810: else if (c >= 'A' && c <= 'F')
1.1.1.2 root 811: digit = c - 'A' + 10;
1.1 root 812: else
813: {
814: (*string_ptr)--;
815: break;
816: }
1.1.1.2 root 817: overflow |= i ^ (i << 4 >> 4);
818: i = (i << 4) + digit;
819: digits_found = 1;
1.1 root 820: }
1.1.1.2 root 821: if (!digits_found)
822: yyerror ("\\x used with no following hex digits");
823: if (overflow | (i & ~((1 << BITS_PER_UNIT) - 1)))
1.1 root 824: {
825: i &= (1 << BITS_PER_UNIT) - 1;
826: warning ("hex character constant does not fit in a byte");
827: }
828: return i;
829: }
830: default:
831: return c;
832: }
833: }
834:
835: void
836: yyerror (s)
837: char *s;
838: {
839: error (s);
840: longjmp (parse_return_error, 1);
841: }
1.1.1.2 root 842:
843: static void
844: integer_overflow ()
845: {
846: if (pedantic)
847: pedwarn ("integer overflow in preprocessor expression");
848: }
849:
850: static long
851: left_shift (a, b)
852: struct constant *a;
853: unsigned long b;
854: {
855: if (b >= HOST_BITS_PER_LONG)
856: {
857: if (! a->unsignedp && a->value != 0)
858: integer_overflow ();
859: return 0;
860: }
861: else if (a->unsignedp)
862: return (unsigned long) a->value << b;
863: else
864: {
865: long l = a->value << b;
866: if (l >> b != a->value)
867: integer_overflow ();
868: return l;
869: }
870: }
871:
872: static long
873: right_shift (a, b)
874: struct constant *a;
875: unsigned long b;
876: {
877: if (b >= HOST_BITS_PER_LONG)
878: return a->unsignedp ? 0 : a->value >> (HOST_BITS_PER_LONG - 1);
879: else if (a->unsignedp)
880: return (unsigned long) a->value >> b;
881: else
882: return a->value >> b;
883: }
1.1 root 884:
885: /* This page contains the entry point to this file. */
886:
887: /* Parse STRING as an expression, and complain if this fails
888: to use up all of the contents of STRING. */
889: /* We do not support C comments. They should be removed before
890: this function is called. */
891:
892: int
893: parse_c_expression (string)
894: char *string;
895: {
896: lexptr = string;
897:
898: if (lexptr == 0 || *lexptr == 0) {
899: error ("empty #if expression");
900: return 0; /* don't include the #if group */
901: }
902:
903: /* if there is some sort of scanning error, just return 0 and assume
904: the parsing routine has printed an error message somewhere.
905: there is surely a better thing to do than this. */
906: if (setjmp (parse_return_error))
907: return 0;
908:
909: if (yyparse ())
910: return 0; /* actually this is never reached
911: the way things stand. */
912: if (*lexptr)
913: error ("Junk after end of expression.");
914:
915: return expression_value; /* set by yyparse () */
916: }
917:
918: #ifdef TEST_EXP_READER
919: extern int yydebug;
920:
921: /* Main program for testing purposes. */
922: int
923: main ()
924: {
925: int n, c;
926: char buf[1024];
927:
928: /*
929: yydebug = 1;
930: */
931: initialize_random_junk ();
932:
933: for (;;) {
934: printf ("enter expression: ");
935: n = 0;
936: while ((buf[n] = getchar ()) != '\n' && buf[n] != EOF)
937: n++;
938: if (buf[n] == EOF)
939: break;
940: buf[n] = '\0';
941: printf ("parser returned %d\n", parse_c_expression (buf));
942: }
943:
944: return 0;
945: }
946:
947: /* table to tell if char can be part of a C identifier. */
948: unsigned char is_idchar[256];
949: /* table to tell if char can be first char of a c identifier. */
950: unsigned char is_idstart[256];
951: /* table to tell if c is horizontal space. isspace () thinks that
952: newline is space; this is not a good idea for this program. */
953: char is_hor_space[256];
954:
955: /*
956: * initialize random junk in the hash table and maybe other places
957: */
958: initialize_random_junk ()
959: {
960: register int i;
961:
962: /*
963: * Set up is_idchar and is_idstart tables. These should be
964: * faster than saying (is_alpha (c) || c == '_'), etc.
965: * Must do set up these things before calling any routines tthat
966: * refer to them.
967: */
968: for (i = 'a'; i <= 'z'; i++) {
969: ++is_idchar[i - 'a' + 'A'];
970: ++is_idchar[i];
971: ++is_idstart[i - 'a' + 'A'];
972: ++is_idstart[i];
973: }
974: for (i = '0'; i <= '9'; i++)
975: ++is_idchar[i];
976: ++is_idchar['_'];
977: ++is_idstart['_'];
978: #if DOLLARS_IN_IDENTIFIERS
979: ++is_idchar['$'];
980: ++is_idstart['$'];
981: #endif
982:
983: /* horizontal space table */
984: ++is_hor_space[' '];
985: ++is_hor_space['\t'];
986: }
987:
988: error (msg)
989: {
990: printf ("error: %s\n", msg);
991: }
992:
993: warning (msg)
994: {
995: printf ("warning: %s\n", msg);
996: }
997:
998: struct hashnode *
999: lookup (name, len, hash)
1000: char *name;
1001: int len;
1002: int hash;
1003: {
1004: return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
1005: }
1006: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.