1 /* Parse C expressions for CCCP.
2 Copyright (C) 1987, 1992, 1994, 1995 Free Software Foundation.
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
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.
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.
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!
23 Written by Per Bothner 1994. */
25 /* Parse a C expression from text in a string */
34 extern char *xmalloc PARAMS ((unsigned));
35 extern char *xrealloc PARAMS ((char *, unsigned));
37 #ifdef MULTIBYTE_CHARS
45 /* This is used for communicating lists of keywords with cccp.c. */
53 /* Define a generic NULL if one hasn't already been defined. */
60 #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
61 #define GENERIC_PTR void *
63 #define GENERIC_PTR char *
68 #define NULL_PTR ((GENERIC_PTR)0)
71 extern char *xmalloc ();
73 #ifndef CHAR_TYPE_SIZE
74 #define CHAR_TYPE_SIZE BITS_PER_UNIT
78 #define INT_TYPE_SIZE BITS_PER_WORD
81 #ifndef LONG_TYPE_SIZE
82 #define LONG_TYPE_SIZE BITS_PER_WORD
85 #ifndef WCHAR_TYPE_SIZE
86 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
89 #ifndef MAX_CHAR_TYPE_SIZE
90 #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
93 #ifndef MAX_INT_TYPE_SIZE
94 #define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
97 #ifndef MAX_LONG_TYPE_SIZE
98 #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
101 #ifndef MAX_WCHAR_TYPE_SIZE
102 #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
105 /* Yield nonzero if adding two numbers with A's and B's signs can yield a
106 number with SUM's sign, where A, B, and SUM are all C integers. */
107 #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
109 static void integer_overflow ();
110 static long left_shift ();
111 static long right_shift ();
126 #define LEFT_OPERAND_REQUIRED 1
127 #define RIGHT_OPERAND_REQUIRED 2
129 /*#define UNSIGNEDP 8*/
131 #ifndef HOST_BITS_PER_WIDE_INT
133 #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
134 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
135 #define HOST_WIDE_INT long
137 #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
138 #define HOST_WIDE_INT int
145 char rprio; /* Priority of op (relative to it right operand). */
147 char unsignedp; /* true if value should be treated as unsigned */
148 HOST_WIDE_INT value; /* The value logically "right" of op. */
151 /* Take care of parsing a number (anything that starts with a digit).
152 LEN is the number of characters in it. */
154 /* maybe needs to actually deal with floating point numbers */
163 register char *p = start;
165 register unsigned long n = 0, nd, ULONG_MAX_over_base;
166 register int base = 10;
167 register int len = olen;
168 register int overflow = 0;
169 register int digit, largest_digit = 0;
174 for (c = 0; c < len; c++)
176 /* It's a float since it contains a point. */
178 "floating point numbers not allowed in #if expressions");
183 if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
191 /* Some buggy compilers (e.g. MPW C) seem to need both casts. */
192 ULONG_MAX_over_base = ((unsigned long) -1) / ((unsigned long) base);
194 for (; len > 0; len--) {
197 if (c >= '0' && c <= '9')
199 else if (base == 16 && c >= 'a' && c <= 'f')
200 digit = c - 'a' + 10;
201 else if (base == 16 && c >= 'A' && c <= 'F')
202 digit = c - 'A' + 10;
204 /* `l' means long, and `u' means unsigned. */
206 if (c == 'l' || c == 'L')
209 cpp_error (pfile, "two `l's in integer constant");
212 else if (c == 'u' || c == 'U')
215 cpp_error (pfile, "two `u's in integer constant");
225 /* Don't look for any more digits after the suffixes. */
228 if (largest_digit < digit)
229 largest_digit = digit;
230 nd = n * base + digit;
231 overflow |= ULONG_MAX_over_base < n | nd < n;
237 cpp_error (pfile, "Invalid number in #if expression");
242 if (base <= largest_digit)
243 cpp_warning (pfile, "integer constant contains digits beyond the radix");
246 cpp_warning (pfile, "integer constant out of range");
248 /* If too big to be signed, consider it unsigned. */
249 if ((long) n < 0 && ! op.unsignedp)
252 cpp_warning (pfile, "integer constant is so large that it is unsigned");
266 static struct token tokentab2[] = {
280 /* Read one token. */
287 register int namelen;
288 register struct token *toktab;
289 enum cpp_token token;
291 U_CHAR *tok_start, *tok_end;
296 old_written = CPP_WRITTEN (pfile);
297 cpp_skip_hspace (pfile);
298 c = CPP_BUF_PEEK (CPP_BUFFER (pfile));
300 return parse_number (pfile,
301 cpp_read_check_assertion (pfile) ? "1" : "0", 1);
309 token = cpp_get_token (pfile);
310 tok_start = pfile->token_buffer + old_written;
311 tok_end = CPP_PWRITTEN (pfile);
312 pfile->limit = tok_start;
315 case CPP_EOF: /* Should not happen ... */
320 if (CPP_BUFFER (pfile)->fname != NULL)
326 case CPP_HSPACE: case CPP_COMMENT:
329 return parse_number (pfile, tok_start, tok_end - tok_start);
331 cpp_error (pfile, "string constants not allowed in #if expressions");
335 /* This code for reading a character constant
336 handles multicharacter constants and wide characters.
337 It is mostly copied from c-lex.c. */
339 register int result = 0;
340 register num_chars = 0;
341 unsigned width = MAX_CHAR_TYPE_SIZE;
344 U_CHAR *ptr = tok_start;
345 #ifdef MULTIBYTE_CHARS
346 char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + MB_CUR_MAX];
348 char token_buffer[MAX_LONG_TYPE_SIZE/MAX_CHAR_TYPE_SIZE + 1];
355 width = MAX_WCHAR_TYPE_SIZE;
356 #ifdef MULTIBYTE_CHARS
357 max_chars = MB_CUR_MAX;
363 max_chars = MAX_LONG_TYPE_SIZE / width;
366 while (ptr < tok_end && ((c = *ptr++) != '\''))
370 c = cpp_parse_escape (pfile, &ptr);
371 if (width < HOST_BITS_PER_INT
372 && (unsigned) c >= (1 << width))
374 "escape sequence out of range for character");
379 /* Merge character into result; ignore excess chars. */
380 if (num_chars < max_chars + 1)
382 if (width < HOST_BITS_PER_INT)
383 result = (result << width) | (c & ((1 << width) - 1));
386 token_buffer[num_chars - 1] = c;
390 token_buffer[num_chars] = 0;
393 cpp_error (pfile, "malformatted character constant");
394 else if (num_chars == 0)
395 cpp_error (pfile, "empty character constant");
396 else if (num_chars > max_chars)
398 num_chars = max_chars;
399 cpp_error (pfile, "character constant too long");
401 else if (num_chars != 1 && ! CPP_TRADITIONAL (pfile))
402 cpp_warning (pfile, "multi-character character constant");
404 /* If char type is signed, sign-extend the constant. */
407 int num_bits = num_chars * width;
409 if (cpp_lookup (pfile, "__CHAR_UNSIGNED__",
410 sizeof ("__CHAR_UNSIGNED__")-1, -1)
411 || ((result >> (num_bits - 1)) & 1) == 0)
413 = result & ((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
416 = result | ~((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
420 #ifdef MULTIBYTE_CHARS
421 /* Set the initial shift state and convert the next sequence. */
423 /* In all locales L'\0' is zero and mbtowc will return zero,
426 || (num_chars == 1 && token_buffer[0] != '\0'))
429 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
430 if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
433 cpp_warning (pfile,"Ignoring invalid multibyte character");
440 /* This is always a signed type. */
447 return parse_number (pfile, "0", 0);
450 /* See if it is a special token of length 2. */
451 if (tok_start + 2 == tok_end)
453 for (toktab = tokentab2; toktab->operator != NULL; toktab++)
454 if (tok_start[0] == toktab->operator[0]
455 && tok_start[1] == toktab->operator[1])
457 if (toktab->token == ERROR)
459 char *buf = (char *) alloca (40);
460 sprintf (buf, "`%s' not allowed in operand of `#if'", tok_start);
461 cpp_error (pfile, buf);
463 op.op = toktab->token;
474 /* Parse a C escape sequence. STRING_PTR points to a variable
475 containing a pointer to the string to parse. That pointer
476 is updated past the characters we use. The value of the
477 escape sequence is returned.
479 A negative value means the sequence \ newline was seen,
480 which is supposed to be equivalent to nothing at all.
482 If \ is followed by a null character, we return a negative
483 value and leave the string pointer pointing at the null character.
485 If \ is followed by 000, we return 0 and leave the string pointer
486 after the zeros. A value of 0 does not mean end of string. */
493 register int c = *(*string_ptr)++;
502 if (CPP_PEDANTIC (pfile))
503 cpp_pedwarn (pfile, "non-ANSI-standard escape sequence, `\\%c'", c);
508 return TARGET_NEWLINE;
530 register int i = c - '0';
531 register int count = 0;
534 c = *(*string_ptr)++;
535 if (c >= '0' && c <= '7')
536 i = (i << 3) + c - '0';
543 if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
545 i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
547 "octal character constant does not fit in a byte");
553 register unsigned i = 0, overflow = 0, digits_found = 0, digit;
556 c = *(*string_ptr)++;
557 if (c >= '0' && c <= '9')
559 else if (c >= 'a' && c <= 'f')
560 digit = c - 'a' + 10;
561 else if (c >= 'A' && c <= 'F')
562 digit = c - 'A' + 10;
568 overflow |= i ^ (i << 4 >> 4);
569 i = (i << 4) + digit;
573 cpp_error (pfile, "\\x used with no following hex digits");
574 if (overflow | (i & ~((1 << BITS_PER_UNIT) - 1)))
576 i &= (1 << BITS_PER_UNIT) - 1;
578 "hex character constant does not fit in a byte");
591 if (CPP_PEDANTIC (pfile))
592 cpp_pedwarn (pfile, "integer overflow in preprocessor expression");
602 if (b >= HOST_BITS_PER_LONG)
604 if (! unsignedp && a != 0)
605 integer_overflow (pfile);
609 return (unsigned long) a << b;
614 integer_overflow (pfile);
626 if (b >= HOST_BITS_PER_LONG)
627 return unsignedp ? 0 : a >> (HOST_BITS_PER_LONG - 1);
629 return (unsigned long) a >> b;
634 /* These priorities are all even, so we can handle associatively. */
635 #define PAREN_INNER_PRIO 0
637 #define COND_PRIO (COMMA_PRIO+2)
638 #define OROR_PRIO (COND_PRIO+2)
639 #define ANDAND_PRIO (OROR_PRIO+2)
640 #define OR_PRIO (ANDAND_PRIO+2)
641 #define XOR_PRIO (OR_PRIO+2)
642 #define AND_PRIO (XOR_PRIO+2)
643 #define EQUAL_PRIO (AND_PRIO+2)
644 #define LESS_PRIO (EQUAL_PRIO+2)
645 #define SHIFT_PRIO (LESS_PRIO+2)
646 #define PLUS_PRIO (SHIFT_PRIO+2)
647 #define MUL_PRIO (PLUS_PRIO+2)
648 #define UNARY_PRIO (MUL_PRIO+2)
649 #define PAREN_OUTER_PRIO (UNARY_PRIO+2)
651 #define COMPARE(OP) \
653 top->value = (unsigned1 || unsigned2) ? (unsigned long) v1 OP v2 : (v1 OP v2)
655 /* Parse and evaluate a C expression, reading from PFILE.
656 Returns the value of the expression. */
662 /* The implementation is an operator precedence parser,
663 i.e. a bottom-up parser, using a stack for not-yet-reduced tokens.
665 The stack base is 'stack', and the current stack pointer is 'top'.
666 There is a stack element for each operator (only),
667 and the most recently pushed operator is 'top->op'.
668 An operand (value) is stored in the 'value' field of the stack
669 element of the operator that precedes it.
670 In that case the 'flags' field has the HAVE_VALUE flag set. */
672 #define INIT_STACK_SIZE 20
673 struct operation init_stack[INIT_STACK_SIZE];
674 struct operation *stack = init_stack;
675 struct operation *limit = stack + INIT_STACK_SIZE;
676 register struct operation *top = stack;
687 op = cpp_lex (pfile);
689 /* See if the token is an operand, in which case go to set_value.
690 If the token is an operator, figure out its left and right
691 priorities, and then goto maybe_reduce. */
696 top->value = 0, top->unsignedp = 0;
699 top->value = op.value;
700 top->unsignedp = op.unsignedp;
703 lprio = 0; goto maybe_reduce;
705 /* Is this correct if unary ? FIXME */
706 flags = RIGHT_OPERAND_REQUIRED;
707 lprio = PLUS_PRIO; rprio = lprio + 1; goto maybe_reduce;
709 flags = RIGHT_OPERAND_REQUIRED;
710 rprio = UNARY_PRIO; lprio = rprio + 1; goto maybe_reduce;
711 case '*': case '/': case '%':
712 lprio = MUL_PRIO; goto binop;
713 case '<': case '>': case LEQ: case GEQ:
714 lprio = LESS_PRIO; goto binop;
715 case EQUAL: case NOTEQUAL:
716 lprio = EQUAL_PRIO; goto binop;
718 lprio = SHIFT_PRIO; goto binop;
719 case '&': lprio = AND_PRIO; goto binop;
720 case '^': lprio = XOR_PRIO; goto binop;
721 case '|': lprio = OR_PRIO; goto binop;
722 case ANDAND: lprio = ANDAND_PRIO; goto binop;
723 case OROR: lprio = OROR_PRIO; goto binop;
725 lprio = COMMA_PRIO; goto binop;
727 lprio = PAREN_OUTER_PRIO; rprio = PAREN_INNER_PRIO;
730 lprio = PAREN_INNER_PRIO; rprio = PAREN_OUTER_PRIO;
733 lprio = COND_PRIO; rprio = COND_PRIO;
736 lprio = COND_PRIO + 1; rprio = COND_PRIO;
739 flags = LEFT_OPERAND_REQUIRED|RIGHT_OPERAND_REQUIRED;
743 cpp_error (pfile, "invalid character in #if");
748 /* Push a value onto the stack. */
749 if (top->flags & HAVE_VALUE)
751 cpp_error (pfile, "syntax error in #if");
754 top->flags |= HAVE_VALUE;
758 /* Push an operator, and check if we can reduce now. */
759 while (top->rprio > lprio)
761 long v1 = top[-1].value, v2 = top[0].value;
762 int unsigned1 = top[-1].unsignedp, unsigned2 = top[0].unsignedp;
764 if ((top[1].flags & LEFT_OPERAND_REQUIRED)
765 && ! (top[0].flags & HAVE_VALUE))
767 cpp_error (pfile, "syntax error - missing left operand");
770 if ((top[1].flags & RIGHT_OPERAND_REQUIRED)
771 && ! (top[1].flags & HAVE_VALUE))
773 cpp_error (pfile, "syntax error - missing right operand");
776 /* top[0].value = (top[1].op)(v1, v2);*/
780 if (!(top->flags & HAVE_VALUE))
783 top->unsignedp = unsigned2;
784 top->flags |= HAVE_VALUE;
788 top->value = v1 + v2;
789 top->unsignedp = unsigned1 || unsigned2;
791 && ! possible_sum_sign (v1, v2, top->value))
792 integer_overflow (pfile);
796 if (!(top->flags & HAVE_VALUE))
799 if ((top->value & v2) < 0 && ! unsigned2)
800 integer_overflow (pfile);
801 top->unsignedp = unsigned2;
802 top->flags |= HAVE_VALUE;
806 top->value = v1 - v2;
807 top->unsignedp = unsigned1 || unsigned2;
809 && ! possible_sum_sign (top->value, v2, v1))
810 integer_overflow (pfile);
814 top->unsignedp = unsigned1 || unsigned2;
816 top->value = (unsigned long) v1 * v2;
819 top->value = v1 * v2;
821 && (top->value / v1 != v2
822 || (top->value & v1 & v2) < 0))
823 integer_overflow (pfile);
829 cpp_error (pfile, "division by zero in #if");
832 top->unsignedp = unsigned1 || unsigned2;
834 top->value = (unsigned long) v1 / v2;
837 top->value = v1 / v2;
838 if ((top->value & v1 & v2) < 0)
839 integer_overflow (pfile);
845 cpp_error (pfile, "division by zero in #if");
848 top->unsignedp = unsigned1 || unsigned2;
850 top->value = (unsigned long) v1 % v2;
852 top->value = v1 % v2;
855 if (top->flags & HAVE_VALUE)
857 cpp_error (pfile, "syntax error");
862 top->flags |= HAVE_VALUE;
865 if (top->flags & HAVE_VALUE)
867 cpp_error (pfile, "syntax error");
871 top->unsignedp = unsigned2;
872 top->flags |= HAVE_VALUE;
874 case '<': COMPARE(<); break;
875 case '>': COMPARE(>); break;
876 case LEQ: COMPARE(<=); break;
877 case GEQ: COMPARE(>=); break;
879 top->value = (v1 == v2);
883 top->value = (v1 != v2);
887 top->unsignedp = unsigned1;
888 if (v2 < 0 && ! unsigned2)
889 top->value = right_shift (pfile, v1, unsigned1, -v2);
891 top->value = left_shift (pfile, v1, unsigned1, v2);
894 top->unsignedp = unsigned1;
895 if (v2 < 0 && ! unsigned2)
896 top->value = left_shift (pfile, v1, unsigned1, -v2);
898 top->value = right_shift (pfile, v1, unsigned1, v2);
900 #define LOGICAL(OP) \
901 top->value = v1 OP v2;\
902 top->unsignedp = unsigned1 || unsigned2;
903 case '&': LOGICAL(&); break;
904 case '^': LOGICAL(^); break;
905 case '|': LOGICAL(|); break;
907 top->value = v1 && v2; top->unsignedp = 0; break;
909 top->value = v1 || v2; top->unsignedp = 0; break;
911 if (CPP_PEDANTIC (pfile))
912 cpp_pedwarn (pfile, "comma operator in operand of `#if'");
914 top->unsignedp = unsigned2;
917 cpp_error (pfile, "syntax error in #if");
920 if (top[0].op != '?')
923 "syntax error ':' without preceding '?'");
926 else if (! (top[1].flags & HAVE_VALUE)
927 || !(top[-1].flags & HAVE_VALUE)
928 || !(top[0].flags & HAVE_VALUE))
930 cpp_error (pfile, "bad syntax for ?: operator");
936 top->value = top->value ? v1 : v2;
937 top->unsignedp = unsigned1 || unsigned2;
941 if ((top[1].flags & HAVE_VALUE)
942 || ! (top[0].flags & HAVE_VALUE)
944 || (top[-1].flags & HAVE_VALUE))
946 cpp_error (pfile, "mismatched parentheses in #if");
953 top->unsignedp = unsigned1;
954 top->flags |= HAVE_VALUE;
959 top[1].op >= ' ' && top[1].op <= '~'
960 ? "unimplemented operator '%c'\n"
961 : "unimplemented operator '\\%03o'\n",
968 cpp_error (pfile, "internal error in #if expression");
969 if (stack != init_stack)
975 /* Check for and handle stack overflow. */
978 struct operation *new_stack;
979 int old_size = (char*)limit - (char*)stack;
980 int new_size = 2 * old_size;
981 if (stack != init_stack)
982 new_stack = (struct operation*) xrealloc (stack, new_size);
985 new_stack = (struct operation*) xmalloc (new_size);
986 bcopy ((char *) stack, (char *) new_stack, old_size);
989 top = (struct operation*)((char*) new_stack + old_size);
990 limit = (struct operation*)((char*) new_stack + new_size);
998 if (stack != init_stack)
1000 skip_rest_of_line (pfile);