1 /* Lexical analyzer for C and Objective C.
2 Copyright (C) 1987, 88, 89, 92, 94-97, 1998 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
36 /* MULTIBYTE_CHARS support only works for native compilers.
37 ??? Ideally what we want is to model widechar support after
38 the current floating point support. */
40 #undef MULTIBYTE_CHARS
43 #ifdef MULTIBYTE_CHARS
49 extern cpp_reader parse_in;
50 extern cpp_options parse_options;
52 /* Stream for reading from the input file. */
56 /* The elements of `ridpointers' are identifier nodes
57 for the reserved type names and storage classes.
58 It is indexed by a RID_... value. */
59 tree ridpointers[(int) RID_MAX];
61 /* Cause the `yydebug' variable to be defined. */
65 extern unsigned char *yy_cur, *yy_lim;
67 extern int yy_get_token ();
69 #define GETC() (yy_cur < yy_lim ? *yy_cur++ : yy_get_token ())
70 #define UNGETC(c) ((c), yy_cur--)
72 #define GETC() getc (finput)
73 #define UNGETC(c) ungetc (c, finput)
76 /* the declaration found for the last IDENTIFIER token read in.
77 yylex must look this up to detect typedefs, which get token type TYPENAME,
78 so it is left around in case the identifier is not a typedef but is
79 used in a context which makes it a reference to a variable. */
82 /* Nonzero enables objc features. */
88 /* File used for outputting assembler code. */
89 extern FILE *asm_out_file;
91 #ifndef WCHAR_TYPE_SIZE
93 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
95 #define WCHAR_TYPE_SIZE BITS_PER_WORD
99 /* Number of bytes in a wide character. */
100 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
102 static int maxtoken; /* Current nominal length of token buffer. */
103 char *token_buffer; /* Pointer to token buffer.
104 Actual allocated length is maxtoken + 2.
105 This is not static because objc-parse.y uses it. */
107 static int indent_level = 0; /* Number of { minus number of }. */
109 /* Nonzero if end-of-file has been seen on input. */
110 static int end_of_file;
113 /* Buffered-back input character; faster than using ungetc. */
114 static int nextchar = -1;
117 #ifdef HANDLE_SYSV_PRAGMA
118 static int handle_sysv_pragma PROTO((int));
119 #endif /* HANDLE_SYSV_PRAGMA */
120 static int whitespace_cr PROTO((int));
121 static int skip_white_space PROTO((int));
122 static int skip_white_space_on_line PROTO((void));
123 static char *extend_token_buffer PROTO((char *));
124 static int readescape PROTO((int *));
125 int check_newline ();
127 /* Do not insert generated code into the source, instead, include it.
128 This allows us to build gcc automatically even for targets that
129 need to add or modify the reserved keyword lists. */
132 /* Return something to represent absolute declarators containing a *.
133 TARGET is the absolute declarator that the * contains.
134 TYPE_QUALS is a list of modifiers such as const or volatile
135 to apply to the pointer type, represented as identifiers.
137 We return an INDIRECT_REF whose "contents" are TARGET
138 and whose type is the modifier list. */
141 make_pointer_declarator (type_quals, target)
142 tree type_quals, target;
144 return build1 (INDIRECT_REF, type_quals, target);
148 forget_protocol_qualifiers ()
150 int i, n = sizeof wordlist / sizeof (struct resword);
152 for (i = 0; i < n; i++)
153 if ((int) wordlist[i].rid >= (int) RID_IN
154 && (int) wordlist[i].rid <= (int) RID_ONEWAY)
155 wordlist[i].name = "";
159 remember_protocol_qualifiers ()
161 int i, n = sizeof wordlist / sizeof (struct resword);
163 for (i = 0; i < n; i++)
164 if (wordlist[i].rid == RID_IN)
165 wordlist[i].name = "in";
166 else if (wordlist[i].rid == RID_OUT)
167 wordlist[i].name = "out";
168 else if (wordlist[i].rid == RID_INOUT)
169 wordlist[i].name = "inout";
170 else if (wordlist[i].rid == RID_BYCOPY)
171 wordlist[i].name = "bycopy";
172 else if (wordlist[i].rid == RID_ONEWAY)
173 wordlist[i].name = "oneway";
177 init_parse (filename)
181 /* Open input file. */
182 if (filename == 0 || !strcmp (filename, "-"))
188 finput = fopen (filename, "r");
190 pfatal_with_name (filename);
192 #ifdef IO_BUFFER_SIZE
193 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
195 #endif /* !USE_CPPLIB */
203 cpp_reader_init (&parse_in);
204 parse_in.data = &parse_options;
205 cpp_options_init (&parse_options);
206 cpp_handle_options (&parse_in, 0, NULL); /* FIXME */
207 parse_in.show_column = 1;
208 if (! cpp_start_read (&parse_in, filename))
219 cpp_finish (&parse_in);
228 /* Make identifier nodes long enough for the language-specific slots. */
229 set_identifier_size (sizeof (struct lang_identifier));
231 /* Start it at 0, because check_newline is called at the very beginning
232 and will increment it to 1. */
235 #ifdef MULTIBYTE_CHARS
236 /* Change to the native locale for multibyte conversions. */
237 setlocale (LC_CTYPE, "");
241 token_buffer = (char *) xmalloc (maxtoken + 2);
243 ridpointers[(int) RID_INT] = get_identifier ("int");
244 ridpointers[(int) RID_CHAR] = get_identifier ("char");
245 ridpointers[(int) RID_VOID] = get_identifier ("void");
246 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
247 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
248 ridpointers[(int) RID_SHORT] = get_identifier ("short");
249 ridpointers[(int) RID_LONG] = get_identifier ("long");
250 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
251 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
252 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
253 ridpointers[(int) RID_CONST] = get_identifier ("const");
254 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
255 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
256 ridpointers[(int) RID_STATIC] = get_identifier ("static");
257 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
258 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
259 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
260 ridpointers[(int) RID_ITERATOR] = get_identifier ("iterator");
261 ridpointers[(int) RID_COMPLEX] = get_identifier ("complex");
262 ridpointers[(int) RID_ID] = get_identifier ("id");
263 ridpointers[(int) RID_IN] = get_identifier ("in");
264 ridpointers[(int) RID_OUT] = get_identifier ("out");
265 ridpointers[(int) RID_INOUT] = get_identifier ("inout");
266 ridpointers[(int) RID_BYCOPY] = get_identifier ("bycopy");
267 ridpointers[(int) RID_ONEWAY] = get_identifier ("oneway");
268 forget_protocol_qualifiers();
270 /* Some options inhibit certain reserved words.
271 Clear those words out of the hash table so they won't be recognized. */
272 #define UNSET_RESERVED_WORD(STRING) \
273 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
274 if (s) s->name = ""; } while (0)
276 if (! doing_objc_thang)
277 UNSET_RESERVED_WORD ("id");
279 if (flag_traditional)
281 UNSET_RESERVED_WORD ("const");
282 UNSET_RESERVED_WORD ("volatile");
283 UNSET_RESERVED_WORD ("typeof");
284 UNSET_RESERVED_WORD ("signed");
285 UNSET_RESERVED_WORD ("inline");
286 UNSET_RESERVED_WORD ("iterator");
287 UNSET_RESERVED_WORD ("complex");
291 UNSET_RESERVED_WORD ("asm");
292 UNSET_RESERVED_WORD ("typeof");
293 UNSET_RESERVED_WORD ("inline");
294 UNSET_RESERVED_WORD ("iterator");
295 UNSET_RESERVED_WORD ("complex");
300 reinit_parse_for_function ()
304 /* Function used when yydebug is set, to print a token in more detail. */
307 yyprint (file, yychar, yylval)
319 if (IDENTIFIER_POINTER (t))
320 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
325 if (TREE_CODE (t) == INTEGER_CST)
327 #if HOST_BITS_PER_WIDE_INT == 64
328 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
331 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
338 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
344 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
349 /* Iff C is a carriage return, warn about it - if appropriate -
350 and return nonzero. */
355 static int newline_warning = 0;
359 /* ANSI C says the effects of a carriage return in a source file
361 if (pedantic && !newline_warning)
363 warning ("carriage return in source file");
364 warning ("(we only warn about the first carriage return)");
372 /* If C is not whitespace, return C.
373 Otherwise skip whitespace and return first nonwhite char read. */
383 /* We don't recognize comments here, because
384 cpp output can include / and * consecutively as operators.
385 Also, there's no need, since cpp removes all comments. */
388 c = check_newline ();
409 error ("stray '\\' in program");
419 /* Skips all of the white space at the current location in the input file.
420 Must use and reset nextchar if it has the next character. */
423 position_after_white_space ()
429 c = nextchar, nextchar = -1;
434 UNGETC (skip_white_space (c));
437 /* Like skip_white_space, but don't advance beyond the end of line.
438 Moreover, we don't get passed a character to start with. */
440 skip_white_space_on_line ()
469 /* Make the token buffer longer, preserving the data in it.
470 P should point to just beyond the last valid character in the old buffer.
471 The value we return is a pointer to the new buffer
472 at a place corresponding to P. */
475 extend_token_buffer (p)
478 int offset = p - token_buffer;
480 maxtoken = maxtoken * 2 + 10;
481 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
483 return token_buffer + offset;
486 /* At the beginning of a line, increment the line number
487 and process any #-directive on this line.
488 If the line is a #-directive, read the entire line and return a newline.
489 Otherwise, return the line's first non-whitespace character. */
499 /* Read first nonwhite char on the line. */
502 while (c == ' ' || c == '\t')
507 /* If not #, return it so caller will use it. */
511 /* Read first nonwhite char after the `#'. */
514 while (c == ' ' || c == '\t')
517 /* If a letter follows, then if the word here is `line', skip
518 it and ignore it; otherwise, ignore the line, with an error
519 if the word isn't `pragma', `ident', `define', or `undef'. */
521 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
530 && ((c = GETC()) == ' ' || c == '\t' || c == '\n'
531 || whitespace_cr (c) ))
533 while (c == ' ' || c == '\t' || whitespace_cr (c))
537 #ifdef HANDLE_SYSV_PRAGMA
540 if (token != IDENTIFIER)
542 return handle_sysv_pragma (token);
543 #else /* !HANDLE_SYSV_PRAGMA */
548 if (token != IDENTIFIER)
550 if (HANDLE_PRAGMA (finput, yylval.ttype))
556 ??? do not know what to do ???;
557 #endif /* !USE_CPPLIB */
558 #endif /* HANDLE_PRAGMA */
559 #endif /* !HANDLE_SYSV_PRAGMA */
571 && ((c = GETC()) == ' ' || c == '\t' || c == '\n'))
574 debug_define (lineno, GET_DIRECTIVE_LINE ());
584 && ((c = GETC()) == ' ' || c == '\t' || c == '\n'))
587 debug_undef (lineno, GET_DIRECTIVE_LINE ());
596 && ((c = GETC()) == ' ' || c == '\t'))
605 && ((c = GETC()) == ' ' || c == '\t'))
607 /* #ident. The pedantic warning is now in cccp.c. */
609 /* Here we have just seen `#ident '.
610 A string constant should follow. */
612 c = skip_white_space_on_line ();
614 /* If no argument, ignore the line. */
621 || TREE_CODE (yylval.ttype) != STRING_CST)
623 error ("invalid #ident");
629 #ifdef ASM_OUTPUT_IDENT
630 ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
634 /* Skip the rest of this line. */
639 error ("undefined or invalid # directive");
644 /* Here we have either `#line' or `# <nonletter>'.
645 In either case, it should be a line number; a digit should follow. */
647 /* Can't use skip_white_space here, but must handle all whitespace
648 that is not '\n', lest we get a recursion for '\r' '\n' when
651 c = skip_white_space_on_line ();
653 /* If the # is the only nonwhite char on the line,
654 just ignore it. Check the new newline. */
658 /* Something follows the #; read a token. */
663 if (token == CONSTANT
664 && TREE_CODE (yylval.ttype) == INTEGER_CST)
666 int old_lineno = lineno;
668 /* subtract one, because it is the following line that
669 gets the specified number */
671 int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
673 /* Is this the last nonwhite stuff on the line? */
674 c = skip_white_space_on_line ();
677 /* No more: store the line number and check following line. */
683 /* More follows: it must be a string constant (filename). */
685 /* Read the string constant. */
688 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
690 error ("invalid #line");
695 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
696 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
699 /* Each change of file name
700 reinitializes whether we are now in a system header. */
701 in_system_header = 0;
703 if (main_input_filename == 0)
704 main_input_filename = input_filename;
706 /* Is this the last nonwhite stuff on the line? */
707 c = skip_white_space_on_line ();
710 /* Update the name in the top element of input_file_stack. */
711 if (input_file_stack)
712 input_file_stack->name = input_filename;
721 /* `1' after file name means entering new file.
722 `2' after file name means just left a file. */
724 if (token == CONSTANT
725 && TREE_CODE (yylval.ttype) == INTEGER_CST)
727 if (TREE_INT_CST_LOW (yylval.ttype) == 1)
729 /* Pushing to a new file. */
731 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
732 input_file_stack->line = old_lineno;
733 p->next = input_file_stack;
734 p->name = input_filename;
735 p->indent_level = indent_level;
736 input_file_stack = p;
737 input_file_stack_tick++;
738 debug_start_source_file (input_filename);
741 else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
743 /* Popping out of a file. */
744 if (input_file_stack->next)
746 struct file_stack *p = input_file_stack;
747 if (indent_level != p->indent_level)
749 warning_with_file_and_line
750 (p->name, old_lineno,
751 "This file contains more `%c's than `%c's.",
752 indent_level > p->indent_level ? '{' : '}',
753 indent_level > p->indent_level ? '}' : '{');
755 input_file_stack = p->next;
757 input_file_stack_tick++;
758 debug_end_source_file (input_file_stack->line);
761 error ("#-lines for entering and leaving files don't match");
767 /* Now that we've pushed or popped the input stack,
768 update the name in the top element. */
769 if (input_file_stack)
770 input_file_stack->name = input_filename;
772 /* If we have handled a `1' or a `2',
773 see if there is another number to read. */
776 /* Is this the last nonwhite stuff on the line? */
777 c = skip_white_space_on_line ();
786 /* `3' after file name means this is a system header file. */
788 if (token == CONSTANT
789 && TREE_CODE (yylval.ttype) == INTEGER_CST
790 && TREE_INT_CST_LOW (yylval.ttype) == 3)
791 in_system_header = 1, used_up = 1;
795 /* Is this the last nonwhite stuff on the line? */
796 c = skip_white_space_on_line ();
802 warning ("unrecognized text at end of #line");
805 error ("invalid #-line");
807 /* skip the rest of this line. */
810 if (c != '\n' && c != EOF && nextchar >= 0)
811 c = nextchar, nextchar = -1;
813 while (c != '\n' && c != EOF)
818 #ifdef HANDLE_SYSV_PRAGMA
820 /* Handle a #pragma directive.
821 TOKEN is the token we read after `#pragma'. Processes the entire input
822 line and returns a character for the caller to reread: either \n or EOF. */
824 /* This function has to be in this file, in order to get at
828 handle_sysv_pragma (token)
841 handle_pragma_token (token_buffer, yylval.ttype);
844 handle_pragma_token (token_buffer, 0);
848 c = nextchar, nextchar = -1;
853 while (c == ' ' || c == '\t')
855 if (c == '\n' || c == EOF)
857 handle_pragma_token (0, 0);
865 #endif /* HANDLE_SYSV_PRAGMA */
867 #define ENDFILE -1 /* token that represents end-of-file */
869 /* Read an escape sequence, returning its equivalent as a character,
870 or store 1 in *ignore_ptr if it is backslash-newline. */
873 readescape (ignore_ptr)
876 register int c = GETC();
878 register unsigned count;
879 unsigned firstdig = 0;
885 if (warn_traditional)
886 warning ("the meaning of `\\x' varies with -traditional");
888 if (flag_traditional)
897 if (!(c >= 'a' && c <= 'f')
898 && !(c >= 'A' && c <= 'F')
899 && !(c >= '0' && c <= '9'))
905 if (c >= 'a' && c <= 'f')
906 code += c - 'a' + 10;
907 if (c >= 'A' && c <= 'F')
908 code += c - 'A' + 10;
909 if (c >= '0' && c <= '9')
911 if (code != 0 || count != 0)
920 error ("\\x used with no following hex digits");
922 /* Digits are all 0's. Ok. */
924 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
926 && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
928 pedwarn ("hex escape out of range");
931 case '0': case '1': case '2': case '3': case '4':
932 case '5': case '6': case '7':
935 while ((c <= '7') && (c >= '0') && (count++ < 3))
937 code = (code * 8) + (c - '0');
943 case '\\': case '\'': case '"':
952 return TARGET_NEWLINE;
967 if (warn_traditional)
968 warning ("the meaning of `\\a' varies with -traditional");
970 if (flag_traditional)
975 #if 0 /* Vertical tab is present in common usage compilers. */
976 if (flag_traditional)
984 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
990 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
994 /* `\%' is used to prevent SCCS from getting confused. */
997 pedwarn ("non-ANSI escape sequence `\\%c'", c);
1000 if (c >= 040 && c < 0177)
1001 pedwarn ("unknown escape sequence `\\%c'", c);
1003 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
1013 strcpy (buf, string);
1015 /* We can't print string and character constants well
1016 because the token_buffer contains the result of processing escapes. */
1018 strcat (buf, " at end of input");
1019 else if (token_buffer[0] == 0)
1020 strcat (buf, " at null character");
1021 else if (token_buffer[0] == '"')
1022 strcat (buf, " before string constant");
1023 else if (token_buffer[0] == '\'')
1024 strcat (buf, " before character constant");
1025 else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
1026 sprintf (buf + strlen (buf), " before character 0%o",
1027 (unsigned char) token_buffer[0]);
1029 strcat (buf, " before `%s'");
1031 error (buf, token_buffer);
1041 char long_long_flag;
1044 struct try_type type_sequence[] =
1046 { &integer_type_node, 0, 0, 0},
1047 { &unsigned_type_node, 1, 0, 0},
1048 { &long_integer_type_node, 0, 1, 0},
1049 { &long_unsigned_type_node, 1, 1, 0},
1050 { &long_long_integer_type_node, 0, 1, 1},
1051 { &long_long_unsigned_type_node, 1, 1, 1}
1066 c = nextchar, nextchar = -1;
1071 /* Effectively do c = skip_white_space (c)
1072 but do it faster in the usual cases. */
1085 /* Call skip_white_space so we can warn if appropriate. */
1090 c = skip_white_space (c);
1092 goto found_nonwhite;
1096 token_buffer[0] = c;
1097 token_buffer[1] = 0;
1099 /* yylloc.first_line = lineno; */
1105 token_buffer[0] = 0;
1110 /* Capital L may start a wide-string or wide-character constant. */
1112 register int c = GETC();
1121 goto string_constant;
1128 if (!doing_objc_thang)
1135 /* '@' may start a constant string object. */
1136 register int c = GETC ();
1140 goto string_constant;
1143 /* Fall through to treat '@' as the start of an identifier. */
1146 case 'A': case 'B': case 'C': case 'D': case 'E':
1147 case 'F': case 'G': case 'H': case 'I': case 'J':
1148 case 'K': case 'M': case 'N': case 'O':
1149 case 'P': case 'Q': case 'R': case 'S': case 'T':
1150 case 'U': case 'V': case 'W': case 'X': case 'Y':
1152 case 'a': case 'b': case 'c': case 'd': case 'e':
1153 case 'f': case 'g': case 'h': case 'i': case 'j':
1154 case 'k': case 'l': case 'm': case 'n': case 'o':
1155 case 'p': case 'q': case 'r': case 's': case 't':
1156 case 'u': case 'v': case 'w': case 'x': case 'y':
1162 while (ISALNUM (c) || c == '_' || c == '$' || c == '@')
1164 /* Make sure this char really belongs in an identifier. */
1165 if (c == '@' && ! doing_objc_thang)
1169 if (! dollars_in_ident)
1170 error ("`$' in identifier");
1172 pedwarn ("`$' in identifier");
1175 if (p >= token_buffer + maxtoken)
1176 p = extend_token_buffer (p);
1192 /* Try to recognize a keyword. Uses minimum-perfect hash function */
1195 register struct resword *ptr;
1197 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
1200 yylval.ttype = ridpointers[(int) ptr->rid];
1201 value = (int) ptr->token;
1203 /* Only return OBJECTNAME if it is a typedef. */
1204 if (doing_objc_thang && value == OBJECTNAME)
1206 lastiddecl = lookup_name(yylval.ttype);
1208 if (lastiddecl == NULL_TREE
1209 || TREE_CODE (lastiddecl) != TYPE_DECL)
1213 /* Even if we decided to recognize asm, still perhaps warn. */
1215 && (value == ASM_KEYWORD || value == TYPEOF
1216 || ptr->rid == RID_INLINE)
1217 && token_buffer[0] != '_')
1218 pedwarn ("ANSI does not permit the keyword `%s'",
1223 /* If we did not find a keyword, look for an identifier
1226 if (value == IDENTIFIER)
1228 if (token_buffer[0] == '@')
1229 error("invalid identifier `%s'", token_buffer);
1231 yylval.ttype = get_identifier (token_buffer);
1232 lastiddecl = lookup_name (yylval.ttype);
1234 if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1236 /* A user-invisible read-only initialized variable
1237 should be replaced by its value.
1238 We handle only strings since that's the only case used in C. */
1239 else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
1240 && DECL_IGNORED_P (lastiddecl)
1241 && TREE_READONLY (lastiddecl)
1242 && DECL_INITIAL (lastiddecl) != 0
1243 && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
1245 tree stringval = DECL_INITIAL (lastiddecl);
1247 /* Copy the string value so that we won't clobber anything
1248 if we put something in the TREE_CHAIN of this one. */
1249 yylval.ttype = build_string (TREE_STRING_LENGTH (stringval),
1250 TREE_STRING_POINTER (stringval));
1253 else if (doing_objc_thang)
1255 tree objc_interface_decl = is_class_name (yylval.ttype);
1257 if (objc_interface_decl)
1260 yylval.ttype = objc_interface_decl;
1270 /* Check first for common special case: single-digit 0 or 1. */
1273 UNGETC (next_c); /* Always undo this lookahead. */
1274 if (!ISALNUM (next_c) && next_c != '.')
1276 token_buffer[0] = (char)c, token_buffer[1] = '\0';
1277 yylval.ttype = (c == '0') ? integer_zero_node : integer_one_node;
1283 case '2': case '3': case '4':
1284 case '5': case '6': case '7': case '8': case '9':
1289 int largest_digit = 0;
1291 /* for multi-precision arithmetic,
1292 we actually store only HOST_BITS_PER_CHAR bits in each part.
1293 The number of parts is chosen so as to be sufficient to hold
1294 the enough bits to fit into the two HOST_WIDE_INTs that contain
1295 the integer value (this is always at least as many bits as are
1296 in a target `long long' value, but may be wider). */
1297 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1298 int parts[TOTAL_PARTS];
1301 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
1304 for (count = 0; count < TOTAL_PARTS; count++)
1312 *p++ = (c = GETC());
1313 if ((c == 'x') || (c == 'X'))
1316 *p++ = (c = GETC());
1318 /* Leading 0 forces octal unless the 0 is the only digit. */
1319 else if (c >= '0' && c <= '9')
1328 /* Read all the digits-and-decimal-points. */
1331 || (ISALNUM (c) && c != 'l' && c != 'L'
1332 && c != 'u' && c != 'U'
1333 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
1334 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
1339 error ("floating constant may not be in radix 16");
1340 if (floatflag == TOO_MANY_POINTS)
1341 /* We have already emitted an error. Don't need another. */
1343 else if (floatflag == AFTER_POINT)
1345 error ("malformed floating constant");
1346 floatflag = TOO_MANY_POINTS;
1347 /* Avoid another error from atof by forcing all characters
1348 from here on to be ignored. */
1352 floatflag = AFTER_POINT;
1356 /* Accept '.' as the start of a floating-point number
1357 only when it is followed by a digit.
1358 Otherwise, unread the following non-digit
1359 and use the '.' as a structural token. */
1360 if (p == token_buffer + 2 && !ISDIGIT (c))
1371 error ("parse error at `..'");
1374 token_buffer[1] = 0;
1381 /* It is not a decimal point.
1382 It should be a digit (perhaps a hex digit). */
1388 else if (base <= 10)
1390 if (c == 'e' || c == 'E')
1393 floatflag = AFTER_POINT;
1394 break; /* start of exponent */
1396 error ("nondigits in number and not hexadecimal");
1407 if (c >= largest_digit)
1411 for (count = 0; count < TOTAL_PARTS; count++)
1413 parts[count] *= base;
1417 += (parts[count-1] >> HOST_BITS_PER_CHAR);
1419 &= (1 << HOST_BITS_PER_CHAR) - 1;
1425 /* If the extra highest-order part ever gets anything in it,
1426 the number is certainly too big. */
1427 if (parts[TOTAL_PARTS - 1] != 0)
1430 if (p >= token_buffer + maxtoken - 3)
1431 p = extend_token_buffer (p);
1432 *p++ = (c = GETC());
1437 error ("numeric constant with no digits");
1439 if (largest_digit >= base)
1440 error ("numeric constant contains digits beyond the radix");
1442 /* Remove terminating char from the token buffer and delimit the string */
1445 if (floatflag != NOT_FLOAT)
1447 tree type = double_type_node;
1449 int conversion_errno = 0;
1450 REAL_VALUE_TYPE value;
1453 /* Read explicit exponent if any, and put it in tokenbuf. */
1455 if ((c == 'e') || (c == 'E'))
1457 if (p >= token_buffer + maxtoken - 3)
1458 p = extend_token_buffer (p);
1461 if ((c == '+') || (c == '-'))
1467 error ("floating constant exponent has no digits");
1470 if (p >= token_buffer + maxtoken - 3)
1471 p = extend_token_buffer (p);
1479 /* Convert string to a double, checking for overflow. */
1480 if (setjmp (handler))
1482 error ("floating constant out of range");
1487 int fflag = 0, lflag = 0;
1488 /* Copy token_buffer now, while it has just the number
1489 and not the suffixes; once we add `f' or `i',
1490 REAL_VALUE_ATOF may not work any more. */
1491 char *copy = (char *) alloca (p - token_buffer + 1);
1492 bcopy (token_buffer, copy, p - token_buffer + 1);
1494 set_float_handler (handler);
1500 /* Read the suffixes to choose a data type. */
1505 error ("more than one `f' in numeric constant");
1511 error ("more than one `l' in numeric constant");
1517 error ("more than one `i' or `j' in numeric constant");
1519 pedwarn ("ANSI C forbids imaginary numeric constants");
1530 if (p >= token_buffer + maxtoken - 3)
1531 p = extend_token_buffer (p);
1537 /* The second argument, machine_mode, of REAL_VALUE_ATOF
1538 tells the desired precision of the binary result
1539 of decimal-to-binary conversion. */
1544 error ("both `f' and `l' in floating constant");
1546 type = float_type_node;
1548 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
1549 conversion_errno = errno;
1550 /* A diagnostic is required here by some ANSI C testsuites.
1551 This is not pedwarn, become some people don't want
1552 an error for this. */
1553 if (REAL_VALUE_ISINF (value) && pedantic)
1554 warning ("floating point number exceeds range of `float'");
1558 type = long_double_type_node;
1560 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
1561 conversion_errno = errno;
1562 if (REAL_VALUE_ISINF (value) && pedantic)
1563 warning ("floating point number exceeds range of `long double'");
1568 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
1569 conversion_errno = errno;
1570 if (REAL_VALUE_ISINF (value) && pedantic)
1571 warning ("floating point number exceeds range of `double'");
1574 set_float_handler (NULL_PTR);
1577 /* ERANGE is also reported for underflow,
1578 so test the value to distinguish overflow from that. */
1579 if (conversion_errno == ERANGE && !flag_traditional && pedantic
1580 && (REAL_VALUES_LESS (dconst1, value)
1581 || REAL_VALUES_LESS (value, dconstm1)))
1582 warning ("floating point number exceeds range of `double'");
1585 /* If the result is not a number, assume it must have been
1586 due to some error message above, so silently convert
1588 if (REAL_VALUE_ISNAN (value))
1591 /* Create a node with determined type and value. */
1593 yylval.ttype = build_complex (NULL_TREE,
1594 convert (type, integer_zero_node),
1595 build_real (type, value));
1597 yylval.ttype = build_real (type, value);
1601 tree traditional_type, ansi_type, type;
1602 HOST_WIDE_INT high, low;
1603 int spec_unsigned = 0;
1605 int spec_long_long = 0;
1609 traditional_type = ansi_type = type = NULL_TREE;
1612 if (c == 'u' || c == 'U')
1615 error ("two `u's in integer constant");
1618 else if (c == 'l' || c == 'L')
1623 error ("three `l's in integer constant");
1625 pedwarn ("ANSI C forbids long long integer constants");
1630 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
1633 error ("more than one `i' or `j' in numeric constant");
1635 pedwarn ("ANSI C forbids imaginary numeric constants");
1640 if (p >= token_buffer + maxtoken - 3)
1641 p = extend_token_buffer (p);
1646 /* If the constant won't fit in an unsigned long long,
1647 then warn that the constant is out of range. */
1649 /* ??? This assumes that long long and long integer types are
1650 a multiple of 8 bits. This better than the original code
1651 though which assumed that long was exactly 32 bits and long
1652 long was exactly 64 bits. */
1654 bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1657 for (i = bytes; i < TOTAL_PARTS; i++)
1661 pedwarn ("integer constant out of range");
1663 /* This is simplified by the fact that our constant
1664 is always positive. */
1668 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1670 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1671 / HOST_BITS_PER_CHAR)]
1672 << (i * HOST_BITS_PER_CHAR));
1673 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1676 yylval.ttype = build_int_2 (low, high);
1677 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1679 /* If warn_traditional, calculate both the ANSI type and the
1680 traditional type, then see if they disagree.
1681 Otherwise, calculate only the type for the dialect in use. */
1682 if (warn_traditional || flag_traditional)
1684 /* Calculate the traditional type. */
1685 /* Traditionally, any constant is signed;
1686 but if unsigned is specified explicitly, obey that.
1687 Use the smallest size with the right number of bits,
1688 except for one special case with decimal constants. */
1689 if (! spec_long && base != 10
1690 && int_fits_type_p (yylval.ttype, unsigned_type_node))
1691 traditional_type = (spec_unsigned ? unsigned_type_node
1692 : integer_type_node);
1693 /* A decimal constant must be long
1694 if it does not fit in type int.
1695 I think this is independent of whether
1696 the constant is signed. */
1697 else if (! spec_long && base == 10
1698 && int_fits_type_p (yylval.ttype, integer_type_node))
1699 traditional_type = (spec_unsigned ? unsigned_type_node
1700 : integer_type_node);
1701 else if (! spec_long_long)
1702 traditional_type = (spec_unsigned ? long_unsigned_type_node
1703 : long_integer_type_node);
1705 traditional_type = (spec_unsigned
1706 ? long_long_unsigned_type_node
1707 : long_long_integer_type_node);
1709 if (warn_traditional || ! flag_traditional)
1711 /* Calculate the ANSI type. */
1712 if (! spec_long && ! spec_unsigned
1713 && int_fits_type_p (yylval.ttype, integer_type_node))
1714 ansi_type = integer_type_node;
1715 else if (! spec_long && (base != 10 || spec_unsigned)
1716 && int_fits_type_p (yylval.ttype, unsigned_type_node))
1717 ansi_type = unsigned_type_node;
1718 else if (! spec_unsigned && !spec_long_long
1719 && int_fits_type_p (yylval.ttype, long_integer_type_node))
1720 ansi_type = long_integer_type_node;
1721 else if (! spec_long_long
1722 && int_fits_type_p (yylval.ttype,
1723 long_unsigned_type_node))
1724 ansi_type = long_unsigned_type_node;
1725 else if (! spec_unsigned
1726 && int_fits_type_p (yylval.ttype,
1727 long_long_integer_type_node))
1728 ansi_type = long_long_integer_type_node;
1730 ansi_type = long_long_unsigned_type_node;
1733 type = flag_traditional ? traditional_type : ansi_type;
1735 if (warn_traditional && traditional_type != ansi_type)
1737 if (TYPE_PRECISION (traditional_type)
1738 != TYPE_PRECISION (ansi_type))
1739 warning ("width of integer constant changes with -traditional");
1740 else if (TREE_UNSIGNED (traditional_type)
1741 != TREE_UNSIGNED (ansi_type))
1742 warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1744 warning ("width of integer constant may change on other systems with -traditional");
1747 if (pedantic && !flag_traditional && !spec_long_long && !warn
1748 && (TYPE_PRECISION (long_integer_type_node)
1749 < TYPE_PRECISION (type)))
1750 pedwarn ("integer constant out of range");
1752 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1753 warning ("decimal constant is so large that it is unsigned");
1757 if (TYPE_PRECISION (type)
1758 <= TYPE_PRECISION (integer_type_node))
1760 = build_complex (NULL_TREE, integer_zero_node,
1761 convert (integer_type_node,
1764 error ("complex integer constant is too wide for `complex int'");
1766 else if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1767 /* The traditional constant 0x80000000 is signed
1768 but doesn't fit in the range of int.
1769 This will change it to -0x80000000, which does fit. */
1771 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1772 yylval.ttype = convert (type, yylval.ttype);
1773 TREE_OVERFLOW (yylval.ttype)
1774 = TREE_CONSTANT_OVERFLOW (yylval.ttype) = 0;
1777 TREE_TYPE (yylval.ttype) = type;
1783 if (ISALNUM (c) || c == '.' || c == '_' || c == '$'
1784 || (!flag_traditional && (c == '-' || c == '+')
1785 && (p[-1] == 'e' || p[-1] == 'E')))
1786 error ("missing white space after number `%s'", token_buffer);
1788 value = CONSTANT; break;
1794 register int result = 0;
1795 register int num_chars = 0;
1796 unsigned width = TYPE_PRECISION (char_type_node);
1801 width = WCHAR_TYPE_SIZE;
1802 #ifdef MULTIBYTE_CHARS
1803 max_chars = MB_CUR_MAX;
1809 max_chars = TYPE_PRECISION (integer_type_node) / width;
1817 if (c == '\'' || c == EOF)
1823 c = readescape (&ignore);
1826 if (width < HOST_BITS_PER_INT
1827 && (unsigned) c >= (1 << width))
1828 pedwarn ("escape sequence out of range for character");
1829 #ifdef MAP_CHARACTER
1831 c = MAP_CHARACTER (c);
1837 pedwarn ("ANSI C forbids newline in character constant");
1840 #ifdef MAP_CHARACTER
1842 c = MAP_CHARACTER (c);
1846 if (num_chars > maxtoken - 4)
1847 extend_token_buffer (token_buffer);
1849 token_buffer[num_chars] = c;
1851 /* Merge character into result; ignore excess chars. */
1852 if (num_chars < max_chars + 1)
1854 if (width < HOST_BITS_PER_INT)
1855 result = (result << width) | (c & ((1 << width) - 1));
1861 token_buffer[num_chars + 1] = '\'';
1862 token_buffer[num_chars + 2] = 0;
1865 error ("malformatted character constant");
1866 else if (num_chars == 0)
1867 error ("empty character constant");
1868 else if (num_chars > max_chars)
1870 num_chars = max_chars;
1871 error ("character constant too long");
1873 else if (num_chars != 1 && ! flag_traditional)
1874 warning ("multi-character character constant");
1876 /* If char type is signed, sign-extend the constant. */
1879 int num_bits = num_chars * width;
1881 /* We already got an error; avoid invalid shift. */
1882 yylval.ttype = build_int_2 (0, 0);
1883 else if (TREE_UNSIGNED (char_type_node)
1884 || ((result >> (num_bits - 1)) & 1) == 0)
1886 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
1887 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1891 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
1892 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1894 TREE_TYPE (yylval.ttype) = integer_type_node;
1898 #ifdef MULTIBYTE_CHARS
1899 /* Set the initial shift state and convert the next sequence. */
1901 /* In all locales L'\0' is zero and mbtowc will return zero,
1904 || (num_chars == 1 && token_buffer[1] != '\0'))
1907 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1908 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1911 warning ("Ignoring invalid multibyte character");
1914 yylval.ttype = build_int_2 (result, 0);
1915 TREE_TYPE (yylval.ttype) = wchar_type_node;
1926 p = token_buffer + 1;
1928 while (c != '"' && c >= 0)
1933 c = readescape (&ignore);
1937 && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
1938 && c >= (1 << TYPE_PRECISION (char_type_node)))
1939 pedwarn ("escape sequence out of range for character");
1944 pedwarn ("ANSI C forbids newline in string constant");
1948 if (p == token_buffer + maxtoken)
1949 p = extend_token_buffer (p);
1958 error ("Unterminated string constant");
1960 /* We have read the entire constant.
1961 Construct a STRING_CST for the result. */
1965 /* If this is a L"..." wide-string, convert the multibyte string
1966 to a wide character string. */
1967 char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
1970 #ifdef MULTIBYTE_CHARS
1971 len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
1972 if (len < 0 || len >= (p - token_buffer))
1974 warning ("Ignoring invalid multibyte string");
1977 bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
1982 wp = widep + (BYTES_BIG_ENDIAN ? WCHAR_BYTES - 1 : 0);
1983 bzero (widep, (p - token_buffer) * WCHAR_BYTES);
1984 for (cp = token_buffer + 1; cp < p; cp++)
1985 *wp = *cp, wp += WCHAR_BYTES;
1986 len = p - token_buffer - 1;
1989 yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
1990 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
1995 extern tree build_objc_string();
1996 /* Return an Objective-C @"..." constant string object. */
1997 yylval.ttype = build_objc_string (p - token_buffer,
1999 TREE_TYPE (yylval.ttype) = char_array_type_node;
2000 value = OBJC_STRING;
2004 yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
2005 TREE_TYPE (yylval.ttype) = char_array_type_node;
2036 yylval.code = PLUS_EXPR; break;
2038 yylval.code = MINUS_EXPR; break;
2040 yylval.code = BIT_AND_EXPR; break;
2042 yylval.code = BIT_IOR_EXPR; break;
2044 yylval.code = MULT_EXPR; break;
2046 yylval.code = TRUNC_DIV_EXPR; break;
2048 yylval.code = TRUNC_MOD_EXPR; break;
2050 yylval.code = BIT_XOR_EXPR; break;
2052 yylval.code = LSHIFT_EXPR; break;
2054 yylval.code = RSHIFT_EXPR; break;
2056 yylval.code = LT_EXPR; break;
2058 yylval.code = GT_EXPR; break;
2061 token_buffer[1] = c1 = GETC();
2062 token_buffer[2] = 0;
2069 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
2071 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
2073 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
2075 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
2077 value = ASSIGN; goto done;
2083 value = PLUSPLUS; goto done;
2085 value = MINUSMINUS; goto done;
2087 value = ANDAND; goto done;
2089 value = OROR; goto done;
2102 { value = POINTSAT; goto done; }
2106 { value = ']'; goto done; }
2110 { value = '{'; indent_level++; goto done; }
2112 { value = '['; goto done; }
2116 { value = '}'; indent_level--; goto done; }
2120 token_buffer[1] = 0;
2122 if ((c == '<') || (c == '>'))
2123 value = ARITHCOMPARE;
2129 /* Don't make yyparse think this is eof. */
2148 /* yylloc.last_line = lineno; */
2153 /* Sets the value of the 'yydebug' variable to VALUE.
2154 This is a function so we don't have to have YYDEBUG defined
2155 in order to build the compiler. */
2164 warning ("YYDEBUG not defined.");