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