1 /* Lexical analyzer for C and Objective C.
2 Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
36 #ifdef MULTIBYTE_CHARS
45 /* The elements of `ridpointers' are identifier nodes
46 for the reserved type names and storage classes.
47 It is indexed by a RID_... value. */
48 tree ridpointers[(int) RID_MAX];
50 /* Cause the `yydebug' variable to be defined. */
53 /* the declaration found for the last IDENTIFIER token read in.
54 yylex must look this up to detect typedefs, which get token type TYPENAME,
55 so it is left around in case the identifier is not a typedef but is
56 used in a context which makes it a reference to a variable. */
59 /* Nonzero enables objc features. */
63 extern tree is_class_name ();
67 /* File used for outputting assembler code. */
68 extern FILE *asm_out_file;
70 #ifndef WCHAR_TYPE_SIZE
72 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
74 #define WCHAR_TYPE_SIZE BITS_PER_WORD
78 /* Number of bytes in a wide character. */
79 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
81 static int maxtoken; /* Current nominal length of token buffer. */
82 char *token_buffer; /* Pointer to token buffer.
83 Actual allocated length is maxtoken + 2.
84 This is not static because objc-parse.y uses it. */
86 /* Nonzero if end-of-file has been seen on input. */
87 static int end_of_file;
89 /* Buffered-back input character; faster than using ungetc. */
90 static int nextchar = -1;
94 /* Nonzero tells yylex to ignore \ in string constants. */
95 static int ignore_escape_flag = 0;
97 /* C code produced by gperf version 2.5 (GNU C++ version) */
98 /* Command-line: gperf -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ c-parse.gperf */
99 struct resword { char *name; short token; enum rid rid; };
101 #define TOTAL_KEYWORDS 79
102 #define MIN_WORD_LENGTH 2
103 #define MAX_WORD_LENGTH 20
104 #define MIN_HASH_VALUE 10
105 #define MAX_HASH_VALUE 144
106 /* maximum key range = 135, duplicates = 0 */
114 register int unsigned len;
116 static unsigned char asso_values[] =
118 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
119 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
120 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
121 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
122 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
123 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
124 145, 145, 145, 145, 25, 145, 145, 145, 145, 145,
125 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
126 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
127 145, 145, 145, 145, 145, 1, 145, 46, 8, 15,
128 61, 6, 36, 48, 3, 5, 145, 18, 63, 25,
129 29, 76, 1, 145, 13, 2, 1, 51, 37, 9,
130 9, 1, 3, 145, 145, 145, 145, 145,
132 register int hval = len;
138 hval += asso_values[str[2]];
141 hval += asso_values[str[0]];
143 return hval + asso_values[str[len - 1]];
146 static struct resword wordlist[] =
148 {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
150 {"int", TYPESPEC, RID_INT},
152 {"__typeof__", TYPEOF, NORID},
153 {"__signed__", TYPESPEC, RID_SIGNED},
154 {"__imag__", IMAGPART, NORID},
155 {"switch", SWITCH, NORID},
156 {"__inline__", SCSPEC, RID_INLINE},
157 {"else", ELSE, NORID},
158 {"__iterator__", SCSPEC, RID_ITERATOR},
159 {"__inline", SCSPEC, RID_INLINE},
160 {"__extension__", EXTENSION, NORID},
161 {"struct", STRUCT, NORID},
162 {"__real__", REALPART, NORID},
163 {"__const", TYPE_QUAL, RID_CONST},
164 {"while", WHILE, NORID},
165 {"__const__", TYPE_QUAL, RID_CONST},
166 {"case", CASE, NORID},
167 {"__complex__", TYPESPEC, RID_COMPLEX},
168 {"__iterator", SCSPEC, RID_ITERATOR},
169 {"bycopy", TYPE_QUAL, RID_BYCOPY},
171 {"__complex", TYPESPEC, RID_COMPLEX},
173 {"in", TYPE_QUAL, RID_IN},
174 {"break", BREAK, NORID},
175 {"@defs", DEFS, NORID},
177 {"extern", SCSPEC, RID_EXTERN},
179 {"typeof", TYPEOF, NORID},
180 {"typedef", SCSPEC, RID_TYPEDEF},
181 {"__typeof", TYPEOF, NORID},
182 {"sizeof", SIZEOF, NORID},
184 {"return", RETURN, NORID},
185 {"const", TYPE_QUAL, RID_CONST},
186 {"__volatile__", TYPE_QUAL, RID_VOLATILE},
187 {"@private", PRIVATE, NORID},
188 {"@selector", SELECTOR, NORID},
189 {"__volatile", TYPE_QUAL, RID_VOLATILE},
190 {"__asm__", ASM_KEYWORD, NORID},
192 {"continue", CONTINUE, NORID},
193 {"__alignof__", ALIGNOF, NORID},
194 {"__imag", IMAGPART, NORID},
195 {"__attribute__", ATTRIBUTE, NORID},
197 {"__attribute", ATTRIBUTE, NORID},
200 {"@encode", ENCODE, NORID},
201 {"id", OBJECTNAME, RID_ID},
202 {"static", SCSPEC, RID_STATIC},
203 {"@interface", INTERFACE, NORID},
205 {"__signed", TYPESPEC, RID_SIGNED},
207 {"__label__", LABEL, NORID},
209 {"__asm", ASM_KEYWORD, NORID},
210 {"char", TYPESPEC, RID_CHAR},
212 {"inline", SCSPEC, RID_INLINE},
213 {"out", TYPE_QUAL, RID_OUT},
214 {"register", SCSPEC, RID_REGISTER},
215 {"__real", REALPART, NORID},
216 {"short", TYPESPEC, RID_SHORT},
218 {"enum", ENUM, NORID},
219 {"inout", TYPE_QUAL, RID_INOUT},
221 {"oneway", TYPE_QUAL, RID_ONEWAY},
222 {"union", UNION, NORID},
224 {"__alignof", ALIGNOF, NORID},
226 {"@implementation", IMPLEMENTATION, NORID},
228 {"@class", CLASS, NORID},
230 {"@public", PUBLIC, NORID},
231 {"asm", ASM_KEYWORD, NORID},
232 {"",}, {"",}, {"",}, {"",}, {"",},
233 {"default", DEFAULT, NORID},
235 {"void", TYPESPEC, RID_VOID},
237 {"@protected", PROTECTED, NORID},
238 {"@protocol", PROTOCOL, NORID},
240 {"volatile", TYPE_QUAL, RID_VOLATILE},
242 {"signed", TYPESPEC, RID_SIGNED},
243 {"float", TYPESPEC, RID_FLOAT},
244 {"@end", END, NORID},
246 {"unsigned", TYPESPEC, RID_UNSIGNED},
247 {"@compatibility_alias", ALIAS, NORID},
248 {"double", TYPESPEC, RID_DOUBLE},
250 {"auto", SCSPEC, RID_AUTO},
252 {"goto", GOTO, NORID},
253 {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
255 {"",}, {"",}, {"",}, {"",},
256 {"long", TYPESPEC, RID_LONG},
263 is_reserved_word (str, len)
265 register unsigned int len;
267 if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
269 register int key = hash (str, len);
271 if (key <= MAX_HASH_VALUE && key >= 0)
273 register char *s = wordlist[key].name;
275 if (*s == *str && !strcmp (str + 1, s + 1))
276 return &wordlist[key];
282 /* Return something to represent absolute declarators containing a *.
283 TARGET is the absolute declarator that the * contains.
284 TYPE_QUALS is a list of modifiers such as const or volatile
285 to apply to the pointer type, represented as identifiers.
287 We return an INDIRECT_REF whose "contents" are TARGET
288 and whose type is the modifier list. */
291 make_pointer_declarator (type_quals, target)
292 tree type_quals, target;
294 return build1 (INDIRECT_REF, type_quals, target);
298 forget_protocol_qualifiers ()
300 int i, n = sizeof wordlist / sizeof (struct resword);
302 for (i = 0; i < n; i++)
303 if ((int) wordlist[i].rid >= (int) RID_IN
304 && (int) wordlist[i].rid <= (int) RID_ONEWAY)
305 wordlist[i].name = "";
309 remember_protocol_qualifiers ()
311 int i, n = sizeof wordlist / sizeof (struct resword);
313 for (i = 0; i < n; i++)
314 if (wordlist[i].rid == RID_IN)
315 wordlist[i].name = "in";
316 else if (wordlist[i].rid == RID_OUT)
317 wordlist[i].name = "out";
318 else if (wordlist[i].rid == RID_INOUT)
319 wordlist[i].name = "inout";
320 else if (wordlist[i].rid == RID_BYCOPY)
321 wordlist[i].name = "bycopy";
322 else if (wordlist[i].rid == RID_ONEWAY)
323 wordlist[i].name = "oneway";
329 /* Make identifier nodes long enough for the language-specific slots. */
330 set_identifier_size (sizeof (struct lang_identifier));
332 /* Start it at 0, because check_newline is called at the very beginning
333 and will increment it to 1. */
336 #ifdef MULTIBYTE_CHARS
337 /* Change to the native locale for multibyte conversions. */
338 setlocale (LC_CTYPE, "");
342 token_buffer = (char *) xmalloc (maxtoken + 2);
344 ridpointers[(int) RID_INT] = get_identifier ("int");
345 ridpointers[(int) RID_CHAR] = get_identifier ("char");
346 ridpointers[(int) RID_VOID] = get_identifier ("void");
347 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
348 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
349 ridpointers[(int) RID_SHORT] = get_identifier ("short");
350 ridpointers[(int) RID_LONG] = get_identifier ("long");
351 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
352 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
353 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
354 ridpointers[(int) RID_CONST] = get_identifier ("const");
355 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
356 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
357 ridpointers[(int) RID_STATIC] = get_identifier ("static");
358 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
359 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
360 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
361 ridpointers[(int) RID_ITERATOR] = get_identifier ("iterator");
362 ridpointers[(int) RID_COMPLEX] = get_identifier ("complex");
363 ridpointers[(int) RID_ID] = get_identifier ("id");
364 ridpointers[(int) RID_IN] = get_identifier ("in");
365 ridpointers[(int) RID_OUT] = get_identifier ("out");
366 ridpointers[(int) RID_INOUT] = get_identifier ("inout");
367 ridpointers[(int) RID_BYCOPY] = get_identifier ("bycopy");
368 ridpointers[(int) RID_ONEWAY] = get_identifier ("oneway");
369 forget_protocol_qualifiers();
371 /* Some options inhibit certain reserved words.
372 Clear those words out of the hash table so they won't be recognized. */
373 #define UNSET_RESERVED_WORD(STRING) \
374 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
375 if (s) s->name = ""; } while (0)
377 if (! doing_objc_thang)
378 UNSET_RESERVED_WORD ("id");
380 if (flag_traditional)
382 UNSET_RESERVED_WORD ("const");
383 UNSET_RESERVED_WORD ("volatile");
384 UNSET_RESERVED_WORD ("typeof");
385 UNSET_RESERVED_WORD ("signed");
386 UNSET_RESERVED_WORD ("inline");
387 UNSET_RESERVED_WORD ("iterator");
388 UNSET_RESERVED_WORD ("complex");
392 UNSET_RESERVED_WORD ("asm");
393 UNSET_RESERVED_WORD ("typeof");
394 UNSET_RESERVED_WORD ("inline");
395 UNSET_RESERVED_WORD ("iterator");
396 UNSET_RESERVED_WORD ("complex");
401 reinit_parse_for_function ()
405 /* Function used when yydebug is set, to print a token in more detail. */
408 yyprint (file, yychar, yylval)
420 if (IDENTIFIER_POINTER (t))
421 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
426 if (TREE_CODE (t) == INTEGER_CST)
428 #if HOST_BITS_PER_WIDE_INT == 64
429 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
435 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
441 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
447 /* If C is not whitespace, return C.
448 Otherwise skip whitespace and return first nonwhite char read. */
454 static int newline_warning = 0;
460 /* We don't recognize comments here, because
461 cpp output can include / and * consecutively as operators.
462 Also, there's no need, since cpp removes all comments. */
465 c = check_newline ();
477 /* ANSI C says the effects of a carriage return in a source file
479 if (pedantic && !newline_warning)
481 warning ("carriage return in source file");
482 warning ("(we only warn about the first carriage return)");
493 error ("stray '\\' in program");
503 /* Skips all of the white space at the current location in the input file.
504 Must use and reset nextchar if it has the next character. */
507 position_after_white_space ()
512 c = nextchar, nextchar = -1;
516 ungetc (skip_white_space (c), finput);
519 /* Make the token buffer longer, preserving the data in it.
520 P should point to just beyond the last valid character in the old buffer.
521 The value we return is a pointer to the new buffer
522 at a place corresponding to P. */
525 extend_token_buffer (p)
528 int offset = p - token_buffer;
530 maxtoken = maxtoken * 2 + 10;
531 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
533 return token_buffer + offset;
536 /* At the beginning of a line, increment the line number
537 and process any #-directive on this line.
538 If the line is a #-directive, read the entire line and return a newline.
539 Otherwise, return the line's first non-whitespace character. */
549 /* Read first nonwhite char on the line. */
552 while (c == ' ' || c == '\t')
557 /* If not #, return it so caller will use it. */
561 /* Read first nonwhite char after the `#'. */
564 while (c == ' ' || c == '\t')
567 /* If a letter follows, then if the word here is `line', skip
568 it and ignore it; otherwise, ignore the line, with an error
569 if the word isn't `pragma', `ident', `define', or `undef'. */
571 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
575 if (getc (finput) == 'r'
576 && getc (finput) == 'a'
577 && getc (finput) == 'g'
578 && getc (finput) == 'm'
579 && getc (finput) == 'a'
580 && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
582 #ifdef HANDLE_SYSV_PRAGMA
583 return handle_sysv_pragma (finput, c);
584 #endif /* HANDLE_SYSV_PRAGMA */
586 HANDLE_PRAGMA (finput);
587 #endif /* HANDLE_PRAGMA */
594 if (getc (finput) == 'e'
595 && getc (finput) == 'f'
596 && getc (finput) == 'i'
597 && getc (finput) == 'n'
598 && getc (finput) == 'e'
599 && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
601 #ifdef DWARF_DEBUGGING_INFO
602 if ((debug_info_level == DINFO_LEVEL_VERBOSE)
603 && (write_symbols == DWARF_DEBUG))
604 dwarfout_define (lineno, get_directive_line (finput));
605 #endif /* DWARF_DEBUGGING_INFO */
611 if (getc (finput) == 'n'
612 && getc (finput) == 'd'
613 && getc (finput) == 'e'
614 && getc (finput) == 'f'
615 && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
617 #ifdef DWARF_DEBUGGING_INFO
618 if ((debug_info_level == DINFO_LEVEL_VERBOSE)
619 && (write_symbols == DWARF_DEBUG))
620 dwarfout_undef (lineno, get_directive_line (finput));
621 #endif /* DWARF_DEBUGGING_INFO */
627 if (getc (finput) == 'i'
628 && getc (finput) == 'n'
629 && getc (finput) == 'e'
630 && ((c = getc (finput)) == ' ' || c == '\t'))
635 if (getc (finput) == 'd'
636 && getc (finput) == 'e'
637 && getc (finput) == 'n'
638 && getc (finput) == 't'
639 && ((c = getc (finput)) == ' ' || c == '\t'))
641 /* #ident. The pedantic warning is now in cccp.c. */
643 /* Here we have just seen `#ident '.
644 A string constant should follow. */
646 while (c == ' ' || c == '\t')
649 /* If no argument, ignore the line. */
656 || TREE_CODE (yylval.ttype) != STRING_CST)
658 error ("invalid #ident");
664 #ifdef ASM_OUTPUT_IDENT
665 ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
669 /* Skip the rest of this line. */
674 error ("undefined or invalid # directive");
679 /* Here we have either `#line' or `# <nonletter>'.
680 In either case, it should be a line number; a digit should follow. */
682 while (c == ' ' || c == '\t')
685 /* If the # is the only nonwhite char on the line,
686 just ignore it. Check the new newline. */
690 /* Something follows the #; read a token. */
695 if (token == CONSTANT
696 && TREE_CODE (yylval.ttype) == INTEGER_CST)
698 int old_lineno = lineno;
700 /* subtract one, because it is the following line that
701 gets the specified number */
703 int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
705 /* Is this the last nonwhite stuff on the line? */
707 while (c == ' ' || c == '\t')
711 /* No more: store the line number and check following line. */
717 /* More follows: it must be a string constant (filename). */
719 /* Read the string constant, but don't treat \ as special. */
720 ignore_escape_flag = 1;
722 ignore_escape_flag = 0;
724 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
726 error ("invalid #line");
731 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
732 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
735 /* Each change of file name
736 reinitializes whether we are now in a system header. */
737 in_system_header = 0;
739 if (main_input_filename == 0)
740 main_input_filename = input_filename;
742 /* Is this the last nonwhite stuff on the line? */
744 while (c == ' ' || c == '\t')
748 /* Update the name in the top element of input_file_stack. */
749 if (input_file_stack)
750 input_file_stack->name = input_filename;
759 /* `1' after file name means entering new file.
760 `2' after file name means just left a file. */
762 if (token == CONSTANT
763 && TREE_CODE (yylval.ttype) == INTEGER_CST)
765 if (TREE_INT_CST_LOW (yylval.ttype) == 1)
767 /* Pushing to a new file. */
769 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
770 input_file_stack->line = old_lineno;
771 p->next = input_file_stack;
772 p->name = input_filename;
773 input_file_stack = p;
774 input_file_stack_tick++;
775 #ifdef DWARF_DEBUGGING_INFO
776 if (debug_info_level == DINFO_LEVEL_VERBOSE
777 && write_symbols == DWARF_DEBUG)
778 dwarfout_start_new_source_file (input_filename);
779 #endif /* DWARF_DEBUGGING_INFO */
783 else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
785 /* Popping out of a file. */
786 if (input_file_stack->next)
788 struct file_stack *p = input_file_stack;
789 input_file_stack = p->next;
791 input_file_stack_tick++;
792 #ifdef DWARF_DEBUGGING_INFO
793 if (debug_info_level == DINFO_LEVEL_VERBOSE
794 && write_symbols == DWARF_DEBUG)
795 dwarfout_resume_previous_source_file (input_file_stack->line);
796 #endif /* DWARF_DEBUGGING_INFO */
799 error ("#-lines for entering and leaving files don't match");
805 /* Now that we've pushed or popped the input stack,
806 update the name in the top element. */
807 if (input_file_stack)
808 input_file_stack->name = input_filename;
810 /* If we have handled a `1' or a `2',
811 see if there is another number to read. */
814 /* Is this the last nonwhite stuff on the line? */
816 while (c == ' ' || c == '\t')
826 /* `3' after file name means this is a system header file. */
828 if (token == CONSTANT
829 && TREE_CODE (yylval.ttype) == INTEGER_CST
830 && TREE_INT_CST_LOW (yylval.ttype) == 3)
831 in_system_header = 1;
834 error ("invalid #-line");
836 /* skip the rest of this line. */
840 while ((c = getc (finput)) != EOF && c != '\n');
844 #ifdef HANDLE_SYSV_PRAGMA
846 /* Handle a #pragma directive. INPUT is the current input stream,
847 and C is a character to reread. Processes the entire input line
848 and returns a character for the caller to reread: either \n or EOF. */
850 /* This function has to be in this file, in order to get at
854 handle_sysv_pragma (input, c)
860 while (c == ' ' || c == '\t')
862 if (c == '\n' || c == EOF)
864 handle_pragma_token (0, 0);
874 handle_pragma_token (token_buffer, yylval.ttype);
877 handle_pragma_token (token_buffer, 0);
880 c = nextchar, nextchar = -1;
886 #endif /* HANDLE_SYSV_PRAGMA */
888 #define ENDFILE -1 /* token that represents end-of-file */
890 /* Read an escape sequence, returning its equivalent as a character,
891 or store 1 in *ignore_ptr if it is backslash-newline. */
894 readescape (ignore_ptr)
897 register int c = getc (finput);
899 register unsigned count;
906 if (warn_traditional)
907 warning ("the meaning of `\\x' varies with -traditional");
909 if (flag_traditional)
918 if (!(c >= 'a' && c <= 'f')
919 && !(c >= 'A' && c <= 'F')
920 && !(c >= '0' && c <= '9'))
926 if (c >= 'a' && c <= 'f')
927 code += c - 'a' + 10;
928 if (c >= 'A' && c <= 'F')
929 code += c - 'A' + 10;
930 if (c >= '0' && c <= '9')
932 if (code != 0 || count != 0)
941 error ("\\x used with no following hex digits");
943 /* Digits are all 0's. Ok. */
945 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
947 && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
949 pedwarn ("hex escape out of range");
952 case '0': case '1': case '2': case '3': case '4':
953 case '5': case '6': case '7':
956 while ((c <= '7') && (c >= '0') && (count++ < 3))
958 code = (code * 8) + (c - '0');
964 case '\\': case '\'': case '"':
973 return TARGET_NEWLINE;
988 if (warn_traditional)
989 warning ("the meaning of `\\a' varies with -traditional");
991 if (flag_traditional)
996 #if 0 /* Vertical tab is present in common usage compilers. */
997 if (flag_traditional)
1005 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
1011 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
1015 /* `\%' is used to prevent SCCS from getting confused. */
1018 pedwarn ("non-ANSI escape sequence `\\%c'", c);
1021 if (c >= 040 && c < 0177)
1022 pedwarn ("unknown escape sequence `\\%c'", c);
1024 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
1034 strcpy (buf, string);
1036 /* We can't print string and character constants well
1037 because the token_buffer contains the result of processing escapes. */
1039 strcat (buf, " at end of input");
1040 else if (token_buffer[0] == 0)
1041 strcat (buf, " at null character");
1042 else if (token_buffer[0] == '"')
1043 strcat (buf, " before string constant");
1044 else if (token_buffer[0] == '\'')
1045 strcat (buf, " before character constant");
1046 else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
1047 sprintf (buf + strlen (buf), " before character 0%o",
1048 (unsigned char) token_buffer[0]);
1050 strcat (buf, " before `%s'");
1052 error (buf, token_buffer);
1062 char long_long_flag;
1065 struct try_type type_sequence[] =
1067 { &integer_type_node, 0, 0, 0},
1068 { &unsigned_type_node, 1, 0, 0},
1069 { &long_integer_type_node, 0, 1, 0},
1070 { &long_unsigned_type_node, 1, 1, 0},
1071 { &long_long_integer_type_node, 0, 1, 1},
1072 { &long_long_unsigned_type_node, 1, 1, 1}
1086 c = nextchar, nextchar = -1;
1090 /* Effectively do c = skip_white_space (c)
1091 but do it faster in the usual cases. */
1104 /* Call skip_white_space so we can warn if appropriate. */
1109 c = skip_white_space (c);
1111 goto found_nonwhite;
1115 token_buffer[0] = c;
1116 token_buffer[1] = 0;
1118 /* yylloc.first_line = lineno; */
1124 token_buffer[0] = 0;
1129 if (dollars_in_ident)
1134 /* Capital L may start a wide-string or wide-character constant. */
1136 register int c = getc (finput);
1145 goto string_constant;
1152 if (!doing_objc_thang)
1159 /* '@' may start a constant string object. */
1160 register int c = getc(finput);
1164 goto string_constant;
1167 /* Fall through to treat '@' as the start of an indentifier. */
1170 case 'A': case 'B': case 'C': case 'D': case 'E':
1171 case 'F': case 'G': case 'H': case 'I': case 'J':
1172 case 'K': case 'M': case 'N': case 'O':
1173 case 'P': case 'Q': case 'R': case 'S': case 'T':
1174 case 'U': case 'V': case 'W': case 'X': case 'Y':
1176 case 'a': case 'b': case 'c': case 'd': case 'e':
1177 case 'f': case 'g': case 'h': case 'i': case 'j':
1178 case 'k': case 'l': case 'm': case 'n': case 'o':
1179 case 'p': case 'q': case 'r': case 's': case 't':
1180 case 'u': case 'v': case 'w': case 'x': case 'y':
1185 while (isalnum (c) || c == '_' || c == '$' || c == '@')
1187 /* Make sure this char really belongs in an identifier. */
1188 if (c == '@' && ! doing_objc_thang)
1190 if (c == '$' && ! dollars_in_ident)
1193 if (p >= token_buffer + maxtoken)
1194 p = extend_token_buffer (p);
1206 /* Try to recognize a keyword. Uses minimum-perfect hash function */
1209 register struct resword *ptr;
1211 if (ptr = is_reserved_word (token_buffer, p - token_buffer))
1214 yylval.ttype = ridpointers[(int) ptr->rid];
1215 value = (int) ptr->token;
1217 /* Only return OBJECTNAME if it is a typedef. */
1218 if (doing_objc_thang && value == OBJECTNAME)
1220 lastiddecl = lookup_name(yylval.ttype);
1222 if (lastiddecl == NULL_TREE
1223 || TREE_CODE (lastiddecl) != TYPE_DECL)
1227 /* Even if we decided to recognize asm, still perhaps warn. */
1229 && (value == ASM_KEYWORD || value == TYPEOF
1230 || ptr->rid == RID_INLINE)
1231 && token_buffer[0] != '_')
1232 pedwarn ("ANSI does not permit the keyword `%s'",
1237 /* If we did not find a keyword, look for an identifier
1240 if (value == IDENTIFIER)
1242 if (token_buffer[0] == '@')
1243 error("invalid identifier `%s'", token_buffer);
1245 yylval.ttype = get_identifier (token_buffer);
1246 lastiddecl = lookup_name (yylval.ttype);
1248 if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1250 /* A user-invisible read-only initialized variable
1251 should be replaced by its value.
1252 We handle only strings since that's the only case used in C. */
1253 else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
1254 && DECL_IGNORED_P (lastiddecl)
1255 && TREE_READONLY (lastiddecl)
1256 && DECL_INITIAL (lastiddecl) != 0
1257 && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
1259 tree stringval = DECL_INITIAL (lastiddecl);
1261 /* Copy the string value so that we won't clobber anything
1262 if we put something in the TREE_CHAIN of this one. */
1263 yylval.ttype = build_string (TREE_STRING_LENGTH (stringval),
1264 TREE_STRING_POINTER (stringval));
1267 else if (doing_objc_thang)
1269 tree objc_interface_decl = is_class_name (yylval.ttype);
1271 if (objc_interface_decl)
1274 yylval.ttype = objc_interface_decl;
1281 case '0': case '1': case '2': case '3': case '4':
1282 case '5': case '6': case '7': case '8': case '9':
1287 int largest_digit = 0;
1289 /* for multi-precision arithmetic,
1290 we actually store only HOST_BITS_PER_CHAR bits in each part.
1291 The number of parts is chosen so as to be sufficient to hold
1292 the enough bits to fit into the two HOST_WIDE_INTs that contain
1293 the integer value (this is always at least as many bits as are
1294 in a target `long long' value, but may be wider). */
1295 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1296 int parts[TOTAL_PARTS];
1299 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
1302 for (count = 0; count < TOTAL_PARTS; count++)
1310 *p++ = (c = getc (finput));
1311 if ((c == 'x') || (c == 'X'))
1314 *p++ = (c = getc (finput));
1316 /* Leading 0 forces octal unless the 0 is the only digit. */
1317 else if (c >= '0' && c <= '9')
1326 /* Read all the digits-and-decimal-points. */
1329 || (isalnum (c) && c != 'l' && c != 'L'
1330 && c != 'u' && c != 'U'
1331 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
1332 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
1337 error ("floating constant may not be in radix 16");
1338 if (floatflag == AFTER_POINT)
1340 error ("malformed floating constant");
1341 floatflag = TOO_MANY_POINTS;
1344 floatflag = AFTER_POINT;
1347 *p++ = c = getc (finput);
1348 /* Accept '.' as the start of a floating-point number
1349 only when it is followed by a digit.
1350 Otherwise, unread the following non-digit
1351 and use the '.' as a structural token. */
1352 if (p == token_buffer + 2 && !isdigit (c))
1363 error ("parse error at `..'");
1366 token_buffer[1] = 0;
1373 /* It is not a decimal point.
1374 It should be a digit (perhaps a hex digit). */
1380 else if (base <= 10)
1382 if (c == 'e' || c == 'E')
1385 floatflag = AFTER_POINT;
1386 break; /* start of exponent */
1388 error ("nondigits in number and not hexadecimal");
1399 if (c >= largest_digit)
1403 for (count = 0; count < TOTAL_PARTS; count++)
1405 parts[count] *= base;
1409 += (parts[count-1] >> HOST_BITS_PER_CHAR);
1411 &= (1 << HOST_BITS_PER_CHAR) - 1;
1417 /* If the extra highest-order part ever gets anything in it,
1418 the number is certainly too big. */
1419 if (parts[TOTAL_PARTS - 1] != 0)
1422 if (p >= token_buffer + maxtoken - 3)
1423 p = extend_token_buffer (p);
1424 *p++ = (c = getc (finput));
1429 error ("numeric constant with no digits");
1431 if (largest_digit >= base)
1432 error ("numeric constant contains digits beyond the radix");
1434 /* Remove terminating char from the token buffer and delimit the string */
1437 if (floatflag != NOT_FLOAT)
1439 tree type = double_type_node;
1440 int garbage_chars = 0, exceeds_double = 0;
1442 REAL_VALUE_TYPE value;
1445 /* Read explicit exponent if any, and put it in tokenbuf. */
1447 if ((c == 'e') || (c == 'E'))
1449 if (p >= token_buffer + maxtoken - 3)
1450 p = extend_token_buffer (p);
1453 if ((c == '+') || (c == '-'))
1459 error ("floating constant exponent has no digits");
1462 if (p >= token_buffer + maxtoken - 3)
1463 p = extend_token_buffer (p);
1472 /* Convert string to a double, checking for overflow. */
1473 if (setjmp (handler))
1475 error ("floating constant out of range");
1480 set_float_handler (handler);
1482 /* The second argument, machine_mode, of REAL_VALUE_ATOF tells the
1483 desired precision of the binary result of decimal-to-binary conversion. */
1485 /* Read the suffixes to choose a data type. */
1489 type = float_type_node;
1490 value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
1491 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1492 && REAL_VALUE_ISINF (value) && pedantic)
1493 pedwarn ("floating point number exceeds range of `float'");
1498 type = long_double_type_node;
1499 value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
1500 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1501 && REAL_VALUE_ISINF (value) && pedantic)
1503 "floating point number exceeds range of `long double'");
1509 error ("more than one `i' or `j' in numeric constant");
1515 value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
1516 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1517 && REAL_VALUE_ISINF (value) && pedantic)
1518 pedwarn ("floating point number exceeds range of `double'");
1520 set_float_handler (NULL_PTR);
1523 if (errno == ERANGE && !flag_traditional && pedantic)
1525 /* ERANGE is also reported for underflow,
1526 so test the value to distinguish overflow from that. */
1527 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1528 && (REAL_VALUES_LESS (dconst1, value)
1529 || REAL_VALUES_LESS (value, dconstm1)))
1531 pedwarn ("floating point number exceeds range of `double'");
1536 /* Note: garbage_chars is -1 if first char is *not* garbage. */
1537 while (isalnum (c) || c == '.' || c == '_'
1538 || (!flag_traditional && (c == '+' || c == '-')
1539 && (p[-1] == 'e' || p[-1] == 'E')))
1541 if (p >= token_buffer + maxtoken - 3)
1542 p = extend_token_buffer (p);
1547 if (garbage_chars > 0)
1548 error ("garbage at end of number");
1550 /* Create a node with determined type and value. */
1552 yylval.ttype = build_complex (convert (type, integer_zero_node),
1553 build_real (type, value));
1555 yylval.ttype = build_real (type, value);
1562 tree traditional_type, ansi_type, type;
1563 HOST_WIDE_INT high, low;
1564 int spec_unsigned = 0;
1566 int spec_long_long = 0;
1572 if (c == 'u' || c == 'U')
1575 error ("two `u's in integer constant");
1578 else if (c == 'l' || c == 'L')
1583 error ("three `l's in integer constant");
1585 pedwarn ("ANSI C forbids long long integer constants");
1590 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
1593 error ("more than one `i' or `j' in numeric constant");
1598 if (isalnum (c) || c == '.' || c == '_'
1599 || (!flag_traditional && (c == '+' || c == '-')
1600 && (p[-1] == 'e' || p[-1] == 'E')))
1602 error ("garbage at end of number");
1603 while (isalnum (c) || c == '.' || c == '_'
1604 || (!flag_traditional && (c == '+' || c == '-')
1605 && (p[-1] == 'e' || p[-1] == 'E')))
1607 if (p >= token_buffer + maxtoken - 3)
1608 p = extend_token_buffer (p);
1615 if (p >= token_buffer + maxtoken - 3)
1616 p = extend_token_buffer (p);
1623 /* If the constant is not long long and it won't fit in an
1624 unsigned long, or if the constant is long long and won't fit
1625 in an unsigned long long, then warn that the constant is out
1628 /* ??? This assumes that long long and long integer types are
1629 a multiple of 8 bits. This better than the original code
1630 though which assumed that long was exactly 32 bits and long
1631 long was exactly 64 bits. */
1634 bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1636 bytes = TYPE_PRECISION (long_integer_type_node) / 8;
1639 for (i = bytes; i < TOTAL_PARTS; i++)
1643 pedwarn ("integer constant out of range");
1645 /* This is simplified by the fact that our constant
1646 is always positive. */
1650 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1652 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1653 / HOST_BITS_PER_CHAR)]
1654 << (i * HOST_BITS_PER_CHAR));
1655 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1658 yylval.ttype = build_int_2 (low, high);
1659 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1661 /* If warn_traditional, calculate both the ANSI type and the
1662 traditional type, then see if they disagree.
1663 Otherwise, calculate only the type for the dialect in use. */
1664 if (warn_traditional || flag_traditional)
1666 /* Calculate the traditional type. */
1667 /* Traditionally, any constant is signed;
1668 but if unsigned is specified explicitly, obey that.
1669 Use the smallest size with the right number of bits,
1670 except for one special case with decimal constants. */
1671 if (! spec_long && base != 10
1672 && int_fits_type_p (yylval.ttype, unsigned_type_node))
1673 traditional_type = (spec_unsigned ? unsigned_type_node
1674 : integer_type_node);
1675 /* A decimal constant must be long
1676 if it does not fit in type int.
1677 I think this is independent of whether
1678 the constant is signed. */
1679 else if (! spec_long && base == 10
1680 && int_fits_type_p (yylval.ttype, integer_type_node))
1681 traditional_type = (spec_unsigned ? unsigned_type_node
1682 : integer_type_node);
1683 else if (! spec_long_long)
1684 traditional_type = (spec_unsigned ? long_unsigned_type_node
1685 : long_integer_type_node);
1687 traditional_type = (spec_unsigned
1688 ? long_long_unsigned_type_node
1689 : long_long_integer_type_node);
1691 if (warn_traditional || ! flag_traditional)
1693 /* Calculate the ANSI type. */
1694 if (! spec_long && ! spec_unsigned
1695 && int_fits_type_p (yylval.ttype, integer_type_node))
1696 ansi_type = integer_type_node;
1697 else if (! spec_long && (base != 10 || spec_unsigned)
1698 && int_fits_type_p (yylval.ttype, unsigned_type_node))
1699 ansi_type = unsigned_type_node;
1700 else if (! spec_unsigned && !spec_long_long
1701 && int_fits_type_p (yylval.ttype, long_integer_type_node))
1702 ansi_type = long_integer_type_node;
1703 else if (! spec_long_long)
1704 ansi_type = long_unsigned_type_node;
1705 else if (! spec_unsigned
1706 /* Verify value does not overflow into sign bit. */
1707 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
1708 && int_fits_type_p (yylval.ttype,
1709 long_long_integer_type_node))
1710 ansi_type = long_long_integer_type_node;
1712 ansi_type = long_long_unsigned_type_node;
1715 type = flag_traditional ? traditional_type : ansi_type;
1717 if (warn_traditional && traditional_type != ansi_type)
1719 if (TYPE_PRECISION (traditional_type)
1720 != TYPE_PRECISION (ansi_type))
1721 warning ("width of integer constant changes with -traditional");
1722 else if (TREE_UNSIGNED (traditional_type)
1723 != TREE_UNSIGNED (ansi_type))
1724 warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1726 warning ("width of integer constant may change on other systems with -traditional");
1729 if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
1731 pedwarn ("integer constant out of range");
1733 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1734 warning ("decimal constant is so large that it is unsigned");
1738 if (TYPE_PRECISION (type)
1739 <= TYPE_PRECISION (integer_type_node))
1741 = build_complex (integer_zero_node,
1742 convert (integer_type_node, yylval.ttype));
1744 error ("complex integer constant is too wide for `complex int'");
1746 else if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1747 /* The traditional constant 0x80000000 is signed
1748 but doesn't fit in the range of int.
1749 This will change it to -0x80000000, which does fit. */
1751 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1752 yylval.ttype = convert (type, yylval.ttype);
1755 TREE_TYPE (yylval.ttype) = type;
1760 value = CONSTANT; break;
1766 register int result = 0;
1767 register int num_chars = 0;
1768 unsigned width = TYPE_PRECISION (char_type_node);
1773 width = WCHAR_TYPE_SIZE;
1774 #ifdef MULTIBYTE_CHARS
1775 max_chars = MB_CUR_MAX;
1781 max_chars = TYPE_PRECISION (integer_type_node) / width;
1789 if (c == '\'' || c == EOF)
1795 c = readescape (&ignore);
1798 if (width < HOST_BITS_PER_INT
1799 && (unsigned) c >= (1 << width))
1800 pedwarn ("escape sequence out of range for character");
1801 #ifdef MAP_CHARACTER
1803 c = MAP_CHARACTER (c);
1809 pedwarn ("ANSI C forbids newline in character constant");
1812 #ifdef MAP_CHARACTER
1814 c = MAP_CHARACTER (c);
1818 if (num_chars > maxtoken - 4)
1819 extend_token_buffer (token_buffer);
1821 token_buffer[num_chars] = c;
1823 /* Merge character into result; ignore excess chars. */
1824 if (num_chars < max_chars + 1)
1826 if (width < HOST_BITS_PER_INT)
1827 result = (result << width) | (c & ((1 << width) - 1));
1833 token_buffer[num_chars + 1] = '\'';
1834 token_buffer[num_chars + 2] = 0;
1837 error ("malformatted character constant");
1838 else if (num_chars == 0)
1839 error ("empty character constant");
1840 else if (num_chars > max_chars)
1842 num_chars = max_chars;
1843 error ("character constant too long");
1845 else if (num_chars != 1 && ! flag_traditional)
1846 warning ("multi-character character constant");
1848 /* If char type is signed, sign-extend the constant. */
1851 int num_bits = num_chars * width;
1853 /* We already got an error; avoid invalid shift. */
1854 yylval.ttype = build_int_2 (0, 0);
1855 else if (TREE_UNSIGNED (char_type_node)
1856 || ((result >> (num_bits - 1)) & 1) == 0)
1858 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
1859 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1863 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
1864 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1866 TREE_TYPE (yylval.ttype) = integer_type_node;
1870 #ifdef MULTIBYTE_CHARS
1871 /* Set the initial shift state and convert the next sequence. */
1873 /* In all locales L'\0' is zero and mbtowc will return zero,
1876 || (num_chars == 1 && token_buffer[1] != '\0'))
1879 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1880 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1883 warning ("Ignoring invalid multibyte character");
1886 yylval.ttype = build_int_2 (result, 0);
1887 TREE_TYPE (yylval.ttype) = wchar_type_node;
1898 p = token_buffer + 1;
1900 while (c != '"' && c >= 0)
1902 /* ignore_escape_flag is set for reading the filename in #line. */
1903 if (!ignore_escape_flag && c == '\\')
1906 c = readescape (&ignore);
1910 && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
1911 && c >= (1 << TYPE_PRECISION (char_type_node)))
1912 pedwarn ("escape sequence out of range for character");
1917 pedwarn ("ANSI C forbids newline in string constant");
1921 if (p == token_buffer + maxtoken)
1922 p = extend_token_buffer (p);
1930 /* We have read the entire constant.
1931 Construct a STRING_CST for the result. */
1935 /* If this is a L"..." wide-string, convert the multibyte string
1936 to a wide character string. */
1937 char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
1940 #ifdef MULTIBYTE_CHARS
1941 len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
1942 if (len < 0 || len >= (p - token_buffer))
1944 warning ("Ignoring invalid multibyte string");
1947 bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
1950 union { long l; char c[sizeof (long)]; } u;
1954 /* Determine whether host is little or big endian. */
1956 big_endian = u.c[sizeof (long) - 1];
1957 wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
1959 bzero (widep, (p - token_buffer) * WCHAR_BYTES);
1960 for (cp = token_buffer + 1; cp < p; cp++)
1961 *wp = *cp, wp += WCHAR_BYTES;
1962 len = p - token_buffer - 1;
1965 yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
1966 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
1971 extern tree build_objc_string();
1972 /* Return an Objective-C @"..." constant string object. */
1973 yylval.ttype = build_objc_string (p - token_buffer,
1975 TREE_TYPE (yylval.ttype) = char_array_type_node;
1976 value = OBJC_STRING;
1980 yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
1981 TREE_TYPE (yylval.ttype) = char_array_type_node;
2011 yylval.code = PLUS_EXPR; break;
2013 yylval.code = MINUS_EXPR; break;
2015 yylval.code = BIT_AND_EXPR; break;
2017 yylval.code = BIT_IOR_EXPR; break;
2019 yylval.code = MULT_EXPR; break;
2021 yylval.code = TRUNC_DIV_EXPR; break;
2023 yylval.code = TRUNC_MOD_EXPR; break;
2025 yylval.code = BIT_XOR_EXPR; break;
2027 yylval.code = LSHIFT_EXPR; break;
2029 yylval.code = RSHIFT_EXPR; break;
2031 yylval.code = LT_EXPR; break;
2033 yylval.code = GT_EXPR; break;
2036 token_buffer[1] = c1 = getc (finput);
2037 token_buffer[2] = 0;
2044 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
2046 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
2048 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
2050 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
2052 value = ASSIGN; goto done;
2058 value = PLUSPLUS; goto done;
2060 value = MINUSMINUS; goto done;
2062 value = ANDAND; goto done;
2064 value = OROR; goto done;
2072 else if ((c == '-') && (c1 == '>'))
2073 { value = POINTSAT; goto done; }
2074 ungetc (c1, finput);
2075 token_buffer[1] = 0;
2077 if ((c == '<') || (c == '>'))
2078 value = ARITHCOMPARE;
2084 /* Don't make yyparse think this is eof. */
2093 /* yylloc.last_line = lineno; */
2098 /* Sets the value of the 'yydebug' variable to VALUE.
2099 This is a function so we don't have to have YYDEBUG defined
2100 in order to build the compiler. */
2109 warning ("YYDEBUG not defined.");