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