![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cppexp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cppexp.c CVS log | Up to [GCC 2.x] / gcc |
1.1 ! root 1: /* Parse C expressions for CCCP. ! 2: Copyright (C) 1987, 1992, 1994, 1995 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, 59 Temple Place - Suite 330, ! 17: Boston, MA 02111-1307, USA. ! 18: ! 19: In other words, you are welcome to use, share and improve this program. ! 20: You are forbidden to forbid anyone else to use, share and improve ! 21: what you give them. Help stamp out software-hoarding! ! 22: ! 23: Written by Per Bothner 1994. */ ! 24: ! 25: /* Parse a C expression from text in a string */ ! 26: ! 27: #include "config.h" ! 28: #include "cpplib.h" ! 29: ! 30: extern char *xmalloc PARAMS ((unsigned)); ! 31: extern char *xrealloc PARAMS ((char *, unsigned)); ! 32: ! 33: #ifdef MULTIBYTE_CHARS ! 34: #include <stdlib.h> ! 35: #include <locale.h> ! 36: #endif ! 37: ! 38: #include <stdio.h> ! 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: extern char *xmalloc (); ! 67: ! 68: #ifndef CHAR_TYPE_SIZE ! 69: #define CHAR_TYPE_SIZE BITS_PER_UNIT ! 70: #endif ! 71: ! 72: #ifndef INT_TYPE_SIZE ! 73: #define INT_TYPE_SIZE BITS_PER_WORD ! 74: #endif ! 75: ! 76: #ifndef LONG_TYPE_SIZE ! 77: #define LONG_TYPE_SIZE BITS_PER_WORD ! 78: #endif ! 79: ! 80: #ifndef WCHAR_TYPE_SIZE ! 81: #define WCHAR_TYPE_SIZE INT_TYPE_SIZE ! 82: #endif ! 83: ! 84: #ifndef MAX_CHAR_TYPE_SIZE ! 85: #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE ! 86: #endif ! 87: ! 88: #ifndef MAX_INT_TYPE_SIZE ! 89: #define MAX_INT_TYPE_SIZE INT_TYPE_SIZE ! 90: #endif ! 91: ! 92: #ifndef MAX_LONG_TYPE_SIZE ! 93: #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE ! 94: #endif ! 95: ! 96: #ifndef MAX_WCHAR_TYPE_SIZE ! 97: #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE ! 98: #endif ! 99: ! 100: /* Yield nonzero if adding two numbers with A's and B's signs can yield a ! 101: number with SUM's sign, where A, B, and SUM are all C integers. */ ! 102: #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0) ! 103: ! 104: static void integer_overflow (); ! 105: static long left_shift (); ! 106: static long right_shift (); ! 107: ! 108: #define ERROR 299 ! 109: #define OROR 300 ! 110: #define ANDAND 301 ! 111: #define EQUAL 302 ! 112: #define NOTEQUAL 303 ! 113: #define LEQ 304 ! 114: #define GEQ 305 ! 115: #define LSH 306 ! 116: #define RSH 307 ! 117: #define NAME 308 ! 118: #define INT 309 ! 119: #define CHAR 310 ! 120: ! 121: #define LEFT_OPERAND_REQUIRED 1 ! 122: #define RIGHT_OPERAND_REQUIRED 2 ! 123: #define HAVE_VALUE 4 ! 124: /*#define UNSIGNEDP 8*/ ! 125: ! 126: #ifndef HOST_BITS_PER_WIDE_INT ! 127: ! 128: #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT ! 129: #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG ! 130: #define HOST_WIDE_INT long ! 131: #else ! 132: #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT ! 133: #define HOST_WIDE_INT int ! 134: #endif ! 135: ! 136: #endif ! 137: ! 138: struct operation { ! 139: short op; ! 140: char rprio; /* Priority of op (relative to it right operand). */ ! 141: char flags; ! 142: char unsignedp; /* true if value should be treated as unsigned */ ! 143: HOST_WIDE_INT value; /* The value logically "right" of op. */ ! 144: }; ! 145: ! 146: /* Take care of parsing a number (anything that starts with a digit). ! 147: LEN is the number of characters in it. */ ! 148: ! 149: /* maybe needs to actually deal with floating point numbers */ ! 150: ! 151: struct operation ! 152: parse_number (pfile, start, olen) ! 153: cpp_reader *pfile; ! 154: char *start; ! 155: int olen; ! 156: { ! 157: struct operation op; ! 158: register char *p = start; ! 159: register int c; ! 160: register unsigned long n = 0, nd, ULONG_MAX_over_base; ! 161: register int base = 10; ! 162: register int len = olen; ! 163: register int overflow = 0; ! 164: register int digit, largest_digit = 0; ! 165: int spec_long = 0; ! 166: ! 167: op.unsignedp = 0; ! 168: ! 169: for (c = 0; c < len; c++) ! 170: if (p[c] == '.') { ! 171: /* It's a float since it contains a point. */ ! 172: cpp_error (pfile, ! 173: "floating point numbers not allowed in #if expressions"); ! 174: op.op = ERROR; ! 175: return op; ! 176: } ! 177: ! 178: if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) { ! 179: p += 2; ! 180: base = 16; ! 181: len -= 2; ! 182: } ! 183: else if (*p == '0') ! 184: base = 8; ! 185: ! 186: /* Some buggy compilers (e.g. MPW C) seem to need both casts. */ ! 187: ULONG_MAX_over_base = ((unsigned long) -1) / ((unsigned long) base); ! 188: ! 189: for (; len > 0; len--) { ! 190: c = *p++; ! 191: ! 192: if (c >= '0' && c <= '9') ! 193: digit = c - '0'; ! 194: else if (base == 16 && c >= 'a' && c <= 'f') ! 195: digit = c - 'a' + 10; ! 196: else if (base == 16 && c >= 'A' && c <= 'F') ! 197: digit = c - 'A' + 10; ! 198: else { ! 199: /* `l' means long, and `u' means unsigned. */ ! 200: while (1) { ! 201: if (c == 'l' || c == 'L') ! 202: { ! 203: if (spec_long) ! 204: cpp_error (pfile, "two `l's in integer constant"); ! 205: spec_long = 1; ! 206: } ! 207: else if (c == 'u' || c == 'U') ! 208: { ! 209: if (op.unsignedp) ! 210: cpp_error (pfile, "two `u's in integer constant"); ! 211: op.unsignedp = 1; ! 212: } ! 213: else ! 214: break; ! 215: ! 216: if (--len == 0) ! 217: break; ! 218: c = *p++; ! 219: } ! 220: /* Don't look for any more digits after the suffixes. */ ! 221: break; ! 222: } ! 223: if (largest_digit < digit) ! 224: largest_digit = digit; ! 225: nd = n * base + digit; ! 226: overflow |= ULONG_MAX_over_base < n | nd < n; ! 227: n = nd; ! 228: } ! 229: ! 230: if (len != 0) ! 231: { ! 232: cpp_error (pfile, "Invalid number in #if expression"); ! 233: op.op = ERROR; ! 234: return op; ! 235: } ! 236: ! 237: if (base <= largest_digit) ! 238: cpp_warning (pfile, "integer constant contains digits beyond the radix"); ! 239: ! 240: if (overflow) ! 241: cpp_warning (pfile, "integer constant out of range"); ! 242: ! 243: /* If too big to be signed, consider it unsigned. */ ! 244: if ((long) n < 0 && ! op.unsignedp) ! 245: { ! 246: if (base == 10) ! 247: cpp_warning (pfile, "integer constant is so large that it is unsigned"); ! 248: op.unsignedp = 1; ! 249: } ! 250: ! 251: op.value = n; ! 252: op.op = INT; ! 253: return op; ! 254: } ! 255: ! 256: struct token { ! 257: char *operator; ! 258: int token; ! 259: }; ! 260: ! 261: static struct token tokentab2[] = { ! 262: {"&&", ANDAND}, ! 263: {"||", OROR}, ! 264: {"<<", LSH}, ! 265: {">>", RSH}, ! 266: {"==", EQUAL}, ! 267: {"!=", NOTEQUAL}, ! 268: {"<=", LEQ}, ! 269: {">=", GEQ}, ! 270: {"++", ERROR}, ! 271: {"--", ERROR}, ! 272: {NULL, ERROR} ! 273: }; ! 274: ! 275: /* Read one token. */ ! 276: ! 277: struct operation ! 278: cpp_lex (pfile) ! 279: cpp_reader *pfile; ! 280: { ! 281: register int c; ! 282: register int namelen; ! 283: register struct token *toktab; ! 284: enum cpp_token token; ! 285: struct operation op; ! 286: U_CHAR *tok_start, *tok_end; ! 287: int old_written; ! 288: ! 289: retry: ! 290: ! 291: old_written = CPP_WRITTEN (pfile); ! 292: cpp_skip_hspace (pfile); ! 293: c = CPP_BUF_PEEK (CPP_BUFFER (pfile)); ! 294: if (c == '#') ! 295: return parse_number (pfile, ! 296: cpp_read_check_assertion (pfile) ? "1" : "0", 1); ! 297: ! 298: if (c == '\n') ! 299: { ! 300: op.op = 0; ! 301: return op; ! 302: } ! 303: ! 304: token = cpp_get_token (pfile); ! 305: tok_start = pfile->token_buffer + old_written; ! 306: tok_end = CPP_PWRITTEN (pfile); ! 307: pfile->limit = tok_start; ! 308: switch (token) ! 309: { ! 310: case CPP_EOF: /* Should not happen ... */ ! 311: op.op = 0; ! 312: return op; ! 313: case CPP_VSPACE: ! 314: case CPP_POP: ! 315: if (CPP_BUFFER (pfile)->fname != NULL) ! 316: { ! 317: op.op = 0; ! 318: return op; ! 319: } ! 320: goto retry; ! 321: case CPP_HSPACE: case CPP_COMMENT: ! 322: goto retry; ! 323: case CPP_NUMBER: ! 324: return parse_number (pfile, tok_start, tok_end - tok_start); ! 325: case CPP_STRING: ! 326: cpp_error (pfile, "string constants not allowed in #if expressions"); ! 327: op.op = ERROR; ! 328: return op; ! 329: case CPP_CHAR: ! 330: /* This code for reading a character constant ! 331: handles multicharacter constants and wide characters. ! 332: It is mostly copied from c-lex.c. */ ! 333: { ! 334: register int result = 0; ! 335: register num_chars = 0; ! 336: unsigned width = MAX_CHAR_TYPE_SIZE; ! 337: int wide_flag = 0; ! 338: int max_chars; ! 339: U_CHAR *ptr = tok_start; ! 340: #ifdef MULTIBYTE_CHARS ! 341: char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + MB_CUR_MAX]; ! 342: #else ! 343: char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + 1]; ! 344: #endif ! 345: ! 346: if (*ptr == 'L') ! 347: { ! 348: ptr++; ! 349: wide_flag = 1; ! 350: width = MAX_WCHAR_TYPE_SIZE; ! 351: #ifdef MULTIBYTE_CHARS ! 352: max_chars = MB_CUR_MAX; ! 353: #else ! 354: max_chars = 1; ! 355: #endif ! 356: } ! 357: else ! 358: max_chars = MAX_LONG_TYPE_SIZE / width; ! 359: ! 360: ++ptr; ! 361: while (ptr < tok_end && ((c = *ptr++) != '\'')) ! 362: { ! 363: if (c == '\\') ! 364: { ! 365: c = cpp_parse_escape (pfile, &ptr); ! 366: if (width < HOST_BITS_PER_INT ! 367: && (unsigned) c >= (1 << width)) ! 368: cpp_pedwarn (pfile, ! 369: "escape sequence out of range for character"); ! 370: } ! 371: ! 372: num_chars++; ! 373: ! 374: /* Merge character into result; ignore excess chars. */ ! 375: if (num_chars < max_chars + 1) ! 376: { ! 377: if (width < HOST_BITS_PER_INT) ! 378: result = (result << width) | (c & ((1 << width) - 1)); ! 379: else ! 380: result = c; ! 381: token_buffer[num_chars - 1] = c; ! 382: } ! 383: } ! 384: ! 385: token_buffer[num_chars] = 0; ! 386: ! 387: if (c != '\'') ! 388: cpp_error (pfile, "malformatted character constant"); ! 389: else if (num_chars == 0) ! 390: cpp_error (pfile, "empty character constant"); ! 391: else if (num_chars > max_chars) ! 392: { ! 393: num_chars = max_chars; ! 394: cpp_error (pfile, "character constant too long"); ! 395: } ! 396: else if (num_chars != 1 && ! CPP_TRADITIONAL (pfile)) ! 397: cpp_warning (pfile, "multi-character character constant"); ! 398: ! 399: /* If char type is signed, sign-extend the constant. */ ! 400: if (! wide_flag) ! 401: { ! 402: int num_bits = num_chars * width; ! 403: ! 404: if (cpp_lookup (pfile, "__CHAR_UNSIGNED__", ! 405: sizeof ("__CHAR_UNSIGNED__")-1, -1) ! 406: || ((result >> (num_bits - 1)) & 1) == 0) ! 407: op.value ! 408: = result & ((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits)); ! 409: else ! 410: op.value ! 411: = result | ~((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits)); ! 412: } ! 413: else ! 414: { ! 415: #ifdef MULTIBYTE_CHARS ! 416: /* Set the initial shift state and convert the next sequence. */ ! 417: result = 0; ! 418: /* In all locales L'\0' is zero and mbtowc will return zero, ! 419: so don't use it. */ ! 420: if (num_chars > 1 ! 421: || (num_chars == 1 && token_buffer[0] != '\0')) ! 422: { ! 423: wchar_t wc; ! 424: (void) mbtowc (NULL_PTR, NULL_PTR, 0); ! 425: if (mbtowc (& wc, token_buffer, num_chars) == num_chars) ! 426: result = wc; ! 427: else ! 428: cpp_warning (pfile,"Ignoring invalid multibyte character"); ! 429: } ! 430: #endif ! 431: op.value = result; ! 432: } ! 433: } ! 434: ! 435: /* This is always a signed type. */ ! 436: op.unsignedp = 0; ! 437: op.op = CHAR; ! 438: ! 439: return op; ! 440: ! 441: case CPP_NAME: ! 442: return parse_number (pfile, "0", 0); ! 443: ! 444: case CPP_OTHER: ! 445: /* See if it is a special token of length 2. */ ! 446: if (tok_start + 2 == tok_end) ! 447: { ! 448: for (toktab = tokentab2; toktab->operator != NULL; toktab++) ! 449: if (tok_start[0] == toktab->operator[0] ! 450: && tok_start[1] == toktab->operator[1]) ! 451: break; ! 452: if (toktab->token == ERROR) ! 453: { ! 454: char *buf = (char *) alloca (40); ! 455: sprintf (buf, "`%s' not allowed in operand of `#if'", tok_start); ! 456: cpp_error (pfile, buf); ! 457: } ! 458: op.op = toktab->token; ! 459: return op; ! 460: } ! 461: /* fall through */ ! 462: default: ! 463: op.op = *tok_start; ! 464: return op; ! 465: } ! 466: } ! 467: ! 468: ! 469: /* Parse a C escape sequence. STRING_PTR points to a variable ! 470: containing a pointer to the string to parse. That pointer ! 471: is updated past the characters we use. The value of the ! 472: escape sequence is returned. ! 473: ! 474: A negative value means the sequence \ newline was seen, ! 475: which is supposed to be equivalent to nothing at all. ! 476: ! 477: If \ is followed by a null character, we return a negative ! 478: value and leave the string pointer pointing at the null character. ! 479: ! 480: If \ is followed by 000, we return 0 and leave the string pointer ! 481: after the zeros. A value of 0 does not mean end of string. */ ! 482: ! 483: int ! 484: cpp_parse_escape (pfile, string_ptr) ! 485: cpp_reader *pfile; ! 486: char **string_ptr; ! 487: { ! 488: register int c = *(*string_ptr)++; ! 489: switch (c) ! 490: { ! 491: case 'a': ! 492: return TARGET_BELL; ! 493: case 'b': ! 494: return TARGET_BS; ! 495: case 'e': ! 496: case 'E': ! 497: if (CPP_PEDANTIC (pfile)) ! 498: cpp_pedwarn (pfile, "non-ANSI-standard escape sequence, `\\%c'", c); ! 499: return 033; ! 500: case 'f': ! 501: return TARGET_FF; ! 502: case 'n': ! 503: return TARGET_NEWLINE; ! 504: case 'r': ! 505: return TARGET_CR; ! 506: case 't': ! 507: return TARGET_TAB; ! 508: case 'v': ! 509: return TARGET_VT; ! 510: case '\n': ! 511: return -2; ! 512: case 0: ! 513: (*string_ptr)--; ! 514: return 0; ! 515: ! 516: case '0': ! 517: case '1': ! 518: case '2': ! 519: case '3': ! 520: case '4': ! 521: case '5': ! 522: case '6': ! 523: case '7': ! 524: { ! 525: register int i = c - '0'; ! 526: register int count = 0; ! 527: while (++count < 3) ! 528: { ! 529: c = *(*string_ptr)++; ! 530: if (c >= '0' && c <= '7') ! 531: i = (i << 3) + c - '0'; ! 532: else ! 533: { ! 534: (*string_ptr)--; ! 535: break; ! 536: } ! 537: } ! 538: if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0) ! 539: { ! 540: i &= (1 << MAX_CHAR_TYPE_SIZE) - 1; ! 541: cpp_warning (pfile, ! 542: "octal character constant does not fit in a byte"); ! 543: } ! 544: return i; ! 545: } ! 546: case 'x': ! 547: { ! 548: register unsigned i = 0, overflow = 0, digits_found = 0, digit; ! 549: for (;;) ! 550: { ! 551: c = *(*string_ptr)++; ! 552: if (c >= '0' && c <= '9') ! 553: digit = c - '0'; ! 554: else if (c >= 'a' && c <= 'f') ! 555: digit = c - 'a' + 10; ! 556: else if (c >= 'A' && c <= 'F') ! 557: digit = c - 'A' + 10; ! 558: else ! 559: { ! 560: (*string_ptr)--; ! 561: break; ! 562: } ! 563: overflow |= i ^ (i << 4 >> 4); ! 564: i = (i << 4) + digit; ! 565: digits_found = 1; ! 566: } ! 567: if (!digits_found) ! 568: cpp_error (pfile, "\\x used with no following hex digits"); ! 569: if (overflow | (i & ~((1 << BITS_PER_UNIT) - 1))) ! 570: { ! 571: i &= (1 << BITS_PER_UNIT) - 1; ! 572: cpp_warning (pfile, ! 573: "hex character constant does not fit in a byte"); ! 574: } ! 575: return i; ! 576: } ! 577: default: ! 578: return c; ! 579: } ! 580: } ! 581: ! 582: static void ! 583: integer_overflow (pfile) ! 584: cpp_reader *pfile; ! 585: { ! 586: if (CPP_PEDANTIC (pfile)) ! 587: cpp_pedwarn (pfile, "integer overflow in preprocessor expression"); ! 588: } ! 589: ! 590: static long ! 591: left_shift (pfile, a, unsignedp, b) ! 592: cpp_reader *pfile; ! 593: long a; ! 594: int unsignedp; ! 595: unsigned long b; ! 596: { ! 597: if (b >= HOST_BITS_PER_LONG) ! 598: { ! 599: if (! unsignedp && a != 0) ! 600: integer_overflow (pfile); ! 601: return 0; ! 602: } ! 603: else if (unsignedp) ! 604: return (unsigned long) a << b; ! 605: else ! 606: { ! 607: long l = a << b; ! 608: if (l >> b != a) ! 609: integer_overflow (pfile); ! 610: return l; ! 611: } ! 612: } ! 613: ! 614: static long ! 615: right_shift (pfile, a, unsignedp, b) ! 616: cpp_reader *pfile; ! 617: long a; ! 618: int unsignedp; ! 619: unsigned long b; ! 620: { ! 621: if (b >= HOST_BITS_PER_LONG) ! 622: return unsignedp ? 0 : a >> (HOST_BITS_PER_LONG - 1); ! 623: else if (unsignedp) ! 624: return (unsigned long) a >> b; ! 625: else ! 626: return a >> b; ! 627: } ! 628: ! 629: /* These priorities are all even, so we can handle associatively. */ ! 630: #define PAREN_INNER_PRIO 0 ! 631: #define COMMA_PRIO 4 ! 632: #define COND_PRIO (COMMA_PRIO+2) ! 633: #define OROR_PRIO (COND_PRIO+2) ! 634: #define ANDAND_PRIO (OROR_PRIO+2) ! 635: #define OR_PRIO (ANDAND_PRIO+2) ! 636: #define XOR_PRIO (OR_PRIO+2) ! 637: #define AND_PRIO (XOR_PRIO+2) ! 638: #define EQUAL_PRIO (AND_PRIO+2) ! 639: #define LESS_PRIO (EQUAL_PRIO+2) ! 640: #define SHIFT_PRIO (LESS_PRIO+2) ! 641: #define PLUS_PRIO (SHIFT_PRIO+2) ! 642: #define MUL_PRIO (PLUS_PRIO+2) ! 643: #define UNARY_PRIO (MUL_PRIO+2) ! 644: #define PAREN_OUTER_PRIO (UNARY_PRIO+2) ! 645: ! 646: #define COMPARE(OP) \ ! 647: top->unsignedp = 0;\ ! 648: top->value = (unsigned1 || unsigned2) ? (unsigned long) v1 OP v2 : (v1 OP v2) ! 649: ! 650: /* Parse and evaluate a C expression, reading from PFILE. ! 651: Returns the value of the expression. */ ! 652: ! 653: HOST_WIDE_INT ! 654: cpp_parse_expr (pfile) ! 655: cpp_reader *pfile; ! 656: { ! 657: /* The implementation is an operator precedence parser, ! 658: i.e. a bottom-up parser, using a stack for not-yet-reduced tokens. ! 659: ! 660: The stack base is 'stack', and the current stack pointer is 'top'. ! 661: There is a stack element for each operator (only), ! 662: and the most recently pushed operator is 'top->op'. ! 663: An operand (value) is stored in the 'value' field of the stack ! 664: element of the operator that precedes it. ! 665: In that case the 'flags' field has the HAVE_VALUE flag set. */ ! 666: ! 667: #define INIT_STACK_SIZE 20 ! 668: struct operation init_stack[INIT_STACK_SIZE]; ! 669: struct operation *stack = init_stack; ! 670: struct operation *limit = stack + INIT_STACK_SIZE; ! 671: register struct operation *top = stack; ! 672: int lprio, rprio; ! 673: ! 674: top->rprio = 0; ! 675: top->flags = 0; ! 676: for (;;) ! 677: { ! 678: struct operation op; ! 679: char flags = 0; ! 680: ! 681: /* Read a token */ ! 682: op = cpp_lex (pfile); ! 683: ! 684: /* See if the token is an operand, in which case go to set_value. ! 685: If the token is an operator, figure out its left and right ! 686: priorities, and then goto maybe_reduce. */ ! 687: ! 688: switch (op.op) ! 689: { ! 690: case NAME: ! 691: top->value = 0, top->unsignedp = 0; ! 692: goto set_value; ! 693: case INT: case CHAR: ! 694: top->value = op.value; ! 695: top->unsignedp = op.unsignedp; ! 696: goto set_value; ! 697: case 0: ! 698: lprio = 0; goto maybe_reduce; ! 699: case '+': case '-': ! 700: /* Is this correct if unary ? FIXME */ ! 701: flags = RIGHT_OPERAND_REQUIRED; ! 702: lprio = PLUS_PRIO; rprio = lprio + 1; goto maybe_reduce; ! 703: case '!': case '~': ! 704: flags = RIGHT_OPERAND_REQUIRED; ! 705: rprio = UNARY_PRIO; lprio = rprio + 1; goto maybe_reduce; ! 706: case '*': case '/': case '%': ! 707: lprio = MUL_PRIO; goto binop; ! 708: case '<': case '>': case LEQ: case GEQ: ! 709: lprio = LESS_PRIO; goto binop; ! 710: case EQUAL: case NOTEQUAL: ! 711: lprio = EQUAL_PRIO; goto binop; ! 712: case LSH: case RSH: ! 713: lprio = SHIFT_PRIO; goto binop; ! 714: case '&': lprio = AND_PRIO; goto binop; ! 715: case '^': lprio = XOR_PRIO; goto binop; ! 716: case '|': lprio = OR_PRIO; goto binop; ! 717: case ANDAND: lprio = ANDAND_PRIO; goto binop; ! 718: case OROR: lprio = OROR_PRIO; goto binop; ! 719: case ',': ! 720: lprio = COMMA_PRIO; goto binop; ! 721: case '(': ! 722: lprio = PAREN_OUTER_PRIO; rprio = PAREN_INNER_PRIO; ! 723: goto maybe_reduce; ! 724: case ')': ! 725: lprio = PAREN_INNER_PRIO; rprio = PAREN_OUTER_PRIO; ! 726: goto maybe_reduce; ! 727: case ':': ! 728: lprio = COND_PRIO; rprio = COND_PRIO; ! 729: goto maybe_reduce; ! 730: case '?': ! 731: lprio = COND_PRIO + 1; rprio = COND_PRIO; ! 732: goto maybe_reduce; ! 733: binop: ! 734: flags = LEFT_OPERAND_REQUIRED|RIGHT_OPERAND_REQUIRED; ! 735: rprio = lprio + 1; ! 736: goto maybe_reduce; ! 737: default: ! 738: cpp_error (pfile, "invalid character in #if"); ! 739: goto syntax_error; ! 740: } ! 741: ! 742: set_value: ! 743: /* Push a value onto the stack. */ ! 744: if (top->flags & HAVE_VALUE) ! 745: { ! 746: cpp_error (pfile, "syntax error in #if"); ! 747: goto syntax_error; ! 748: } ! 749: top->flags |= HAVE_VALUE; ! 750: continue; ! 751: ! 752: maybe_reduce: ! 753: /* Push an operator, and check if we can reduce now. */ ! 754: while (top->rprio > lprio) ! 755: { ! 756: long v1 = top[-1].value, v2 = top[0].value; ! 757: int unsigned1 = top[-1].unsignedp, unsigned2 = top[0].unsignedp; ! 758: top--; ! 759: if ((top[1].flags & LEFT_OPERAND_REQUIRED) ! 760: && ! (top[0].flags & HAVE_VALUE)) ! 761: { ! 762: cpp_error (pfile, "syntax error - missing left operand"); ! 763: goto syntax_error; ! 764: } ! 765: if ((top[1].flags & RIGHT_OPERAND_REQUIRED) ! 766: && ! (top[1].flags & HAVE_VALUE)) ! 767: { ! 768: cpp_error (pfile, "syntax error - missing right operand"); ! 769: goto syntax_error; ! 770: } ! 771: /* top[0].value = (top[1].op)(v1, v2);*/ ! 772: switch (top[1].op) ! 773: { ! 774: case '+': ! 775: if (!(top->flags & HAVE_VALUE)) ! 776: { /* Unary '+' */ ! 777: top->value = v2; ! 778: top->unsignedp = unsigned2; ! 779: top->flags |= HAVE_VALUE; ! 780: } ! 781: else ! 782: { ! 783: top->value = v1 + v2; ! 784: top->unsignedp = unsigned1 || unsigned2; ! 785: if (! top->unsignedp ! 786: && ! possible_sum_sign (v1, v2, top->value)) ! 787: integer_overflow (pfile); ! 788: } ! 789: break; ! 790: case '-': ! 791: if (!(top->flags & HAVE_VALUE)) ! 792: { /* Unary '-' */ ! 793: top->value = - v2; ! 794: if ((top->value & v2) < 0 && ! unsigned2) ! 795: integer_overflow (pfile); ! 796: top->unsignedp = unsigned2; ! 797: top->flags |= HAVE_VALUE; ! 798: } ! 799: else ! 800: { /* Binary '-' */ ! 801: top->value = v1 - v2; ! 802: top->unsignedp = unsigned1 || unsigned2; ! 803: if (! top->unsignedp ! 804: && ! possible_sum_sign (top->value, v2, v1)) ! 805: integer_overflow (pfile); ! 806: } ! 807: break; ! 808: case '*': ! 809: top->unsignedp = unsigned1 || unsigned2; ! 810: if (top->unsignedp) ! 811: top->value = (unsigned long) v1 * v2; ! 812: else ! 813: { ! 814: top->value = v1 * v2; ! 815: if (v1 ! 816: && (top->value / v1 != v2 ! 817: || (top->value & v1 & v2) < 0)) ! 818: integer_overflow (pfile); ! 819: } ! 820: break; ! 821: case '/': ! 822: if (v2 == 0) ! 823: { ! 824: cpp_error (pfile, "division by zero in #if"); ! 825: v2 = 1; ! 826: } ! 827: top->unsignedp = unsigned1 || unsigned2; ! 828: if (top->unsignedp) ! 829: top->value = (unsigned long) v1 / v2; ! 830: else ! 831: { ! 832: top->value = v1 / v2; ! 833: if ((top->value & v1 & v2) < 0) ! 834: integer_overflow (pfile); ! 835: } ! 836: break; ! 837: case '%': ! 838: if (v2 == 0) ! 839: { ! 840: cpp_error (pfile, "division by zero in #if"); ! 841: v2 = 1; ! 842: } ! 843: top->unsignedp = unsigned1 || unsigned2; ! 844: if (top->unsignedp) ! 845: top->value = (unsigned long) v1 % v2; ! 846: else ! 847: top->value = v1 % v2; ! 848: break; ! 849: case '!': ! 850: if (top->flags & HAVE_VALUE) ! 851: { ! 852: cpp_error (pfile, "syntax error"); ! 853: goto syntax_error; ! 854: } ! 855: top->value = ! v2; ! 856: top->unsignedp = 0; ! 857: top->flags |= HAVE_VALUE; ! 858: break; ! 859: case '~': ! 860: if (top->flags & HAVE_VALUE) ! 861: { ! 862: cpp_error (pfile, "syntax error"); ! 863: goto syntax_error; ! 864: } ! 865: top->value = ~ v2; ! 866: top->unsignedp = unsigned2; ! 867: top->flags |= HAVE_VALUE; ! 868: break; ! 869: case '<': COMPARE(<); break; ! 870: case '>': COMPARE(>); break; ! 871: case LEQ: COMPARE(<=); break; ! 872: case GEQ: COMPARE(>=); break; ! 873: case EQUAL: ! 874: top->value = (v1 == v2); ! 875: top->unsignedp = 0; ! 876: break; ! 877: case NOTEQUAL: ! 878: top->value = (v1 != v2); ! 879: top->unsignedp = 0; ! 880: break; ! 881: case LSH: ! 882: top->unsignedp = unsigned1; ! 883: if (v2 < 0 && ! unsigned2) ! 884: top->value = right_shift (pfile, v1, unsigned1, -v2); ! 885: else ! 886: top->value = left_shift (pfile, v1, unsigned1, v2); ! 887: break; ! 888: case RSH: ! 889: top->unsignedp = unsigned1; ! 890: if (v2 < 0 && ! unsigned2) ! 891: top->value = left_shift (pfile, v1, unsigned1, -v2); ! 892: else ! 893: top->value = right_shift (pfile, v1, unsigned1, v2); ! 894: break; ! 895: #define LOGICAL(OP) \ ! 896: top->value = v1 OP v2;\ ! 897: top->unsignedp = unsigned1 || unsigned2; ! 898: case '&': LOGICAL(&); break; ! 899: case '^': LOGICAL(^); break; ! 900: case '|': LOGICAL(|); break; ! 901: case ANDAND: ! 902: top->value = v1 && v2; top->unsignedp = 0; break; ! 903: case OROR: ! 904: top->value = v1 || v2; top->unsignedp = 0; break; ! 905: case ',': ! 906: if (CPP_PEDANTIC (pfile)) ! 907: cpp_pedwarn (pfile, "comma operator in operand of `#if'"); ! 908: top->value = v2; ! 909: top->unsignedp = unsigned2; ! 910: break; ! 911: case '(': case '?': ! 912: cpp_error (pfile, "syntax error in #if"); ! 913: goto syntax_error; ! 914: case ':': ! 915: if (top[0].op != '?') ! 916: { ! 917: cpp_error (pfile, ! 918: "syntax error ':' without preceding '?'"); ! 919: goto syntax_error; ! 920: } ! 921: else if (! (top[1].flags & HAVE_VALUE) ! 922: || !(top[-1].flags & HAVE_VALUE) ! 923: || !(top[0].flags & HAVE_VALUE)) ! 924: { ! 925: cpp_error (pfile, "bad syntax for ?: operator"); ! 926: goto syntax_error; ! 927: } ! 928: else ! 929: { ! 930: top--; ! 931: top->value = top->value ? v1 : v2; ! 932: top->unsignedp = unsigned1 || unsigned2; ! 933: } ! 934: break; ! 935: case ')': ! 936: if ((top[1].flags & HAVE_VALUE) ! 937: || ! (top[0].flags & HAVE_VALUE) ! 938: || top[0].op != '(' ! 939: || (top[-1].flags & HAVE_VALUE)) ! 940: { ! 941: cpp_error (pfile, "mismatched parentheses in #if"); ! 942: goto syntax_error; ! 943: } ! 944: else ! 945: { ! 946: top--; ! 947: top->value = v1; ! 948: top->unsignedp = unsigned1; ! 949: top->flags |= HAVE_VALUE; ! 950: } ! 951: break; ! 952: default: ! 953: fprintf (stderr, ! 954: top[1].op >= ' ' && top[1].op <= '~' ! 955: ? "unimplemented operator '%c'\n" ! 956: : "unimplemented operator '\\%03o'\n", ! 957: top[1].op); ! 958: } ! 959: } ! 960: if (op.op == 0) ! 961: { ! 962: if (top != stack) ! 963: cpp_error (pfile, "internal error in #if expression"); ! 964: if (stack != init_stack) ! 965: free (stack); ! 966: return top->value; ! 967: } ! 968: top++; ! 969: ! 970: /* Check for and handle stack overflow. */ ! 971: if (top == limit) ! 972: { ! 973: struct operation *new_stack; ! 974: int old_size = (char*)limit - (char*)stack; ! 975: int new_size = 2 * old_size; ! 976: if (stack != init_stack) ! 977: new_stack = (struct operation*) xrealloc (stack, new_size); ! 978: else ! 979: { ! 980: new_stack = (struct operation*) xmalloc (new_size); ! 981: bcopy ((char *) stack, (char *) new_stack, old_size); ! 982: } ! 983: stack = new_stack; ! 984: top = (struct operation*)((char*) new_stack + old_size); ! 985: limit = (struct operation*)((char*) new_stack + new_size); ! 986: } ! 987: ! 988: top->flags = flags; ! 989: top->rprio = rprio; ! 990: top->op = op.op; ! 991: } ! 992: syntax_error: ! 993: if (stack != init_stack) ! 994: free (stack); ! 995: skip_rest_of_line (pfile); ! 996: return 0; ! 997: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.