1 /* Lexical analyzer for C and Objective C.
2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
3 1998, 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
39 /* MULTIBYTE_CHARS support only works for native compilers.
40 ??? Ideally what we want is to model widechar support after
41 the current floating point support. */
43 #undef MULTIBYTE_CHARS
46 #ifdef MULTIBYTE_CHARS
49 #endif /* MULTIBYTE_CHARS */
50 #ifndef GET_ENVIRONMENT
51 #define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
56 extern cpp_reader parse_in;
57 extern cpp_options parse_options;
59 /* Stream for reading from the input file. */
63 extern void yyprint PARAMS ((FILE *, int, YYSTYPE));
65 /* The elements of `ridpointers' are identifier nodes
66 for the reserved type names and storage classes.
67 It is indexed by a RID_... value. */
68 tree ridpointers[(int) RID_MAX];
70 /* Cause the `yydebug' variable to be defined. */
74 extern unsigned char *yy_cur, *yy_lim;
75 extern enum cpp_token cpp_token;
77 extern int yy_get_token ();
79 #define GETC() (yy_cur < yy_lim ? *yy_cur++ : yy_get_token ())
80 #define UNGETC(c) ((c) == EOF ? 0 : yy_cur--)
82 #else /* ! USE_CPPLIB */
84 #define GETC() getch ()
85 #define UNGETC(c) put_back (c)
87 struct putback_buffer {
88 unsigned char *buffer;
93 static struct putback_buffer putback = {NULL, 0, -1};
95 static inline int getch PARAMS ((void));
100 if (putback.index != -1)
102 int ch = putback.buffer[putback.index];
106 return getc (finput);
109 static inline void put_back PARAMS ((int));
117 if (putback.index == putback.buffer_size - 1)
119 putback.buffer_size += 16;
120 putback.buffer = xrealloc (putback.buffer, putback.buffer_size);
122 putback.buffer[++putback.index] = ch;
125 #endif /* ! USE_CPPLIB */
131 /* File used for outputting assembler code. */
132 extern FILE *asm_out_file;
134 #undef WCHAR_TYPE_SIZE
135 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
137 /* Number of bytes in a wide character. */
138 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
140 static int maxtoken; /* Current nominal length of token buffer. */
141 char *token_buffer; /* Pointer to token buffer.
142 Actual allocated length is maxtoken + 2.
143 This is not static because objc-parse.y uses it. */
145 static int indent_level; /* Number of { minus number of }. */
147 /* Nonzero tells yylex to ignore \ in string constants. */
148 static int ignore_escape_flag;
150 /* Nonzero if end-of-file has been seen on input. */
151 static int end_of_file;
153 #ifdef HANDLE_GENERIC_PRAGMAS
154 static int handle_generic_pragma PARAMS ((int));
155 #endif /* HANDLE_GENERIC_PRAGMAS */
156 static int whitespace_cr PARAMS ((int));
157 static int skip_white_space PARAMS ((int));
158 static char *extend_token_buffer PARAMS ((const char *));
159 static int readescape PARAMS ((int *));
160 static void parse_float PARAMS ((PTR));
161 static void extend_token_buffer_to PARAMS ((int));
162 static int read_line_number PARAMS ((int *));
164 /* Do not insert generated code into the source, instead, include it.
165 This allows us to build gcc automatically even for targets that
166 need to add or modify the reserved keyword lists. */
169 /* Return something to represent absolute declarators containing a *.
170 TARGET is the absolute declarator that the * contains.
171 TYPE_QUALS is a list of modifiers such as const or volatile
172 to apply to the pointer type, represented as identifiers.
174 We return an INDIRECT_REF whose "contents" are TARGET
175 and whose type is the modifier list. */
178 make_pointer_declarator (type_quals, target)
179 tree type_quals, target;
181 return build1 (INDIRECT_REF, type_quals, target);
185 forget_protocol_qualifiers ()
187 int i, n = sizeof wordlist / sizeof (struct resword);
189 for (i = 0; i < n; i++)
190 if ((int) wordlist[i].rid >= (int) RID_IN
191 && (int) wordlist[i].rid <= (int) RID_ONEWAY)
192 wordlist[i].name = "";
196 remember_protocol_qualifiers ()
198 int i, n = sizeof wordlist / sizeof (struct resword);
200 for (i = 0; i < n; i++)
201 if (wordlist[i].rid == RID_IN)
202 wordlist[i].name = "in";
203 else if (wordlist[i].rid == RID_OUT)
204 wordlist[i].name = "out";
205 else if (wordlist[i].rid == RID_INOUT)
206 wordlist[i].name = "inout";
207 else if (wordlist[i].rid == RID_BYCOPY)
208 wordlist[i].name = "bycopy";
209 else if (wordlist[i].rid == RID_BYREF)
210 wordlist[i].name = "byref";
211 else if (wordlist[i].rid == RID_ONEWAY)
212 wordlist[i].name = "oneway";
216 init_parse (filename)
217 const char *filename;
220 /* Open input file. */
221 if (filename == 0 || !strcmp (filename, "-"))
227 finput = fopen (filename, "r");
229 pfatal_with_name (filename);
231 #ifdef IO_BUFFER_SIZE
232 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
234 #else /* !USE_CPPLIB */
235 parse_in.show_column = 1;
236 if (! cpp_start_read (&parse_in, filename))
239 if (filename == 0 || !strcmp (filename, "-"))
242 /* cpp_start_read always puts at least one line directive into the
243 token buffer. We must arrange to read it out here. */
244 yy_cur = parse_in.token_buffer;
245 yy_lim = CPP_PWRITTEN (&parse_in);
246 cpp_token = CPP_DIRECTIVE;
261 cpp_finish (&parse_in);
262 errorcount += parse_in.errors;
271 /* Make identifier nodes long enough for the language-specific slots. */
272 set_identifier_size (sizeof (struct lang_identifier));
274 /* Start it at 0, because check_newline is called at the very beginning
275 and will increment it to 1. */
278 #ifdef MULTIBYTE_CHARS
279 /* Change to the native locale for multibyte conversions. */
280 setlocale (LC_CTYPE, "");
281 GET_ENVIRONMENT (literal_codeset, "LANG");
285 token_buffer = (char *) xmalloc (maxtoken + 2);
287 ridpointers[(int) RID_INT] = get_identifier ("int");
288 ridpointers[(int) RID_CHAR] = get_identifier ("char");
289 ridpointers[(int) RID_VOID] = get_identifier ("void");
290 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
291 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
292 ridpointers[(int) RID_SHORT] = get_identifier ("short");
293 ridpointers[(int) RID_LONG] = get_identifier ("long");
294 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
295 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
296 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
297 ridpointers[(int) RID_CONST] = get_identifier ("const");
298 ridpointers[(int) RID_RESTRICT] = get_identifier ("restrict");
299 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
300 ridpointers[(int) RID_BOUNDED] = get_identifier ("__bounded");
301 ridpointers[(int) RID_UNBOUNDED] = get_identifier ("__unbounded");
302 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
303 ridpointers[(int) RID_STATIC] = get_identifier ("static");
304 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
305 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
306 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
307 ridpointers[(int) RID_ITERATOR] = get_identifier ("iterator");
308 ridpointers[(int) RID_COMPLEX] = get_identifier ("complex");
309 ridpointers[(int) RID_ID] = get_identifier ("id");
310 ridpointers[(int) RID_IN] = get_identifier ("in");
311 ridpointers[(int) RID_OUT] = get_identifier ("out");
312 ridpointers[(int) RID_INOUT] = get_identifier ("inout");
313 ridpointers[(int) RID_BYCOPY] = get_identifier ("bycopy");
314 ridpointers[(int) RID_BYREF] = get_identifier ("byref");
315 ridpointers[(int) RID_ONEWAY] = get_identifier ("oneway");
316 forget_protocol_qualifiers();
318 /* Some options inhibit certain reserved words.
319 Clear those words out of the hash table so they won't be recognized. */
320 #define UNSET_RESERVED_WORD(STRING) \
321 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
322 if (s) s->name = ""; } while (0)
324 if (! doing_objc_thang)
325 UNSET_RESERVED_WORD ("id");
327 if (flag_traditional)
329 UNSET_RESERVED_WORD ("const");
330 UNSET_RESERVED_WORD ("restrict");
331 UNSET_RESERVED_WORD ("volatile");
332 UNSET_RESERVED_WORD ("typeof");
333 UNSET_RESERVED_WORD ("signed");
334 UNSET_RESERVED_WORD ("inline");
335 UNSET_RESERVED_WORD ("iterator");
336 UNSET_RESERVED_WORD ("complex");
338 else if (!flag_isoc99)
339 UNSET_RESERVED_WORD ("restrict");
343 UNSET_RESERVED_WORD ("asm");
344 UNSET_RESERVED_WORD ("typeof");
345 UNSET_RESERVED_WORD ("inline");
346 UNSET_RESERVED_WORD ("iterator");
347 UNSET_RESERVED_WORD ("complex");
352 reinit_parse_for_function ()
356 /* Function used when yydebug is set, to print a token in more detail. */
359 yyprint (file, yychar, yylval)
371 if (IDENTIFIER_POINTER (t))
372 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
377 if (TREE_CODE (t) == INTEGER_CST)
379 #if HOST_BITS_PER_WIDE_INT == 64
380 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
383 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
390 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
396 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
401 /* Iff C is a carriage return, warn about it - if appropriate -
402 and return nonzero. */
408 static int newline_warning = 0;
412 /* ANSI C says the effects of a carriage return in a source file
414 if (pedantic && !newline_warning)
416 warning ("carriage return in source file");
417 warning ("(we only warn about the first carriage return)");
425 /* If C is not whitespace, return C.
426 Otherwise skip whitespace and return first nonwhite char read. */
436 /* We don't recognize comments here, because
437 cpp output can include / and * consecutively as operators.
438 Also, there's no need, since cpp removes all comments. */
446 c = check_newline ();
455 /* While processing a # directive we don't get CPP_HSPACE
456 tokens, so we also need to handle whitespace the normal way. */
457 if (cpp_token == CPP_HSPACE)
474 error ("stray '\\' in program");
484 /* Skips all of the white space at the current location in the input file. */
487 position_after_white_space ()
493 UNGETC (skip_white_space (c));
496 /* Make the token buffer longer, preserving the data in it.
497 P should point to just beyond the last valid character in the old buffer.
498 The value we return is a pointer to the new buffer
499 at a place corresponding to P. */
502 extend_token_buffer_to (size)
506 maxtoken = maxtoken * 2 + 10;
507 while (maxtoken < size);
508 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
512 extend_token_buffer (p)
515 int offset = p - token_buffer;
516 extend_token_buffer_to (offset);
517 return token_buffer + offset;
520 #if defined HANDLE_PRAGMA
521 /* Local versions of these macros, that can be passed as function pointers. */
537 read_line_number (num)
540 register int token = yylex ();
542 if (token == CONSTANT
543 && TREE_CODE (yylval.ttype) == INTEGER_CST)
545 *num = TREE_INT_CST_LOW (yylval.ttype);
550 if (token != END_OF_LINE)
551 error ("invalid #-line");
556 /* At the beginning of a line, increment the line number
557 and process any #-directive on this line.
558 If the line is a #-directive, read the entire line and return a newline.
559 Otherwise, return the line's first non-whitespace character.
561 Note that in the case of USE_CPPLIB, we get the whole line as one
562 CPP_DIRECTIVE token. */
570 enum { act_none, act_push, act_pop } action;
571 int old_lineno, action_number, l;
574 /* Read first nonwhite char on the line. */
578 /* In some cases where we're leaving an include file, we can get multiple
579 CPP_HSPACE tokens in a row, so we need to loop. */
580 while (cpp_token == CPP_HSPACE)
585 while (c == ' ' || c == '\t');
592 /* Sequences of multiple newlines are very common; optimize them. */
596 /* If not #, return it so caller will use it. */
600 /* Don't read beyond this line. */
605 if (cpp_token == CPP_VSPACE)
607 /* Format is "<space> <line number> <filename> <newline>".
608 Only the line number is interesting, and even that
609 we can get more efficiently than scanning the line. */
611 lineno = parse_in.lineno - 1;
618 if (token == IDENTIFIER)
620 /* If a letter follows, then if the word here is `line', skip
621 it and ignore it; otherwise, ignore the line, with an error
622 if the word isn't `pragma'. */
624 const char *name = IDENTIFIER_POINTER (yylval.ttype);
626 if (!strcmp (name, "pragma"))
629 if (token != IDENTIFIER
630 || TREE_CODE (yylval.ttype) != IDENTIFIER_NODE)
634 /* We invoke HANDLE_PRAGMA before HANDLE_GENERIC_PRAGMAS
635 (if both are defined), in order to give the back
636 end a chance to override the interpretation of
637 SYSV style pragmas. */
638 if (HANDLE_PRAGMA (pragma_getc, pragma_ungetc,
639 IDENTIFIER_POINTER (yylval.ttype)))
641 #endif /* HANDLE_PRAGMA */
643 #ifdef HANDLE_GENERIC_PRAGMAS
644 if (handle_generic_pragma (token))
646 #endif /* HANDLE_GENERIC_PRAGMAS */
648 /* Issue a warning message if we have been asked to do so.
649 Ignoring unknown pragmas in system header file unless
650 an explcit -Wunknown-pragmas has been given. */
651 if (warn_unknown_pragmas > 1
652 || (warn_unknown_pragmas && ! in_system_header))
653 warning ("ignoring pragma: %s", token_buffer);
657 else if (!strcmp (name, "define"))
659 debug_define (lineno, GET_DIRECTIVE_LINE ());
662 else if (!strcmp (name, "undef"))
664 debug_undef (lineno, GET_DIRECTIVE_LINE ());
667 else if (!strcmp (name, "line"))
673 else if (!strcmp (name, "ident"))
675 /* #ident. The pedantic warning is now in cpp. */
677 /* Here we have just seen `#ident '.
678 A string constant should follow. */
681 if (token == END_OF_LINE)
684 || TREE_CODE (yylval.ttype) != STRING_CST)
686 error ("invalid #ident");
692 #ifdef ASM_OUTPUT_IDENT
693 ASM_OUTPUT_IDENT (asm_out_file,
694 TREE_STRING_POINTER (yylval.ttype));
698 /* Skip the rest of this line. */
702 error ("undefined or invalid # directive `%s'", name);
706 /* If the # is the only nonwhite char on the line,
707 just ignore it. Check the new newline. */
708 if (token == END_OF_LINE)
712 /* Here we have either `#line' or `# <nonletter>'.
713 In either case, it should be a line number; a digit should follow. */
715 if (token != CONSTANT
716 || TREE_CODE (yylval.ttype) != INTEGER_CST)
718 error ("invalid #-line");
722 /* subtract one, because it is the following line that
723 gets the specified number */
725 l = TREE_INT_CST_LOW (yylval.ttype) - 1;
727 /* More follows: it must be a string constant (filename).
728 It would be neat to use cpplib to quickly process the string, but
729 (1) we don't have a handy tokenization of the string, and
730 (2) I don't know how well that would work in the presense
731 of filenames that contain wide characters. */
735 /* Don't treat \ as special if we are processing #line 1 "...".
736 If you want it to be treated specially, use # 1 "...". */
737 ignore_escape_flag = 1;
740 /* Read the string constant. */
743 ignore_escape_flag = 0;
745 if (token == END_OF_LINE)
747 /* No more: store the line number and check following line. */
752 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
754 error ("invalid #line");
758 input_filename = TREE_STRING_POINTER (yylval.ttype);
760 if (main_input_filename == 0)
761 main_input_filename = input_filename;
768 /* Each change of file name
769 reinitializes whether we are now in a system header. */
770 in_system_header = 0;
772 if (!read_line_number (&action_number))
774 /* Update the name in the top element of input_file_stack. */
775 if (input_file_stack)
776 input_file_stack->name = input_filename;
779 /* `1' after file name means entering new file.
780 `2' after file name means just left a file. */
782 if (action_number == 1)
785 read_line_number (&action_number);
787 else if (action_number == 2)
790 read_line_number (&action_number);
792 if (action_number == 3)
794 /* `3' after file name means this is a system header file. */
795 in_system_header = 1;
796 read_line_number (&action_number);
799 /* Do the actions implied by the preceding numbers. */
801 if (action == act_push)
803 /* Pushing to a new file. */
805 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
806 input_file_stack->line = old_lineno;
807 p->next = input_file_stack;
808 p->name = input_filename;
809 p->indent_level = indent_level;
810 input_file_stack = p;
811 input_file_stack_tick++;
812 debug_start_source_file (input_filename);
814 else if (action == act_pop)
816 /* Popping out of a file. */
817 if (input_file_stack->next)
819 struct file_stack *p = input_file_stack;
820 if (indent_level != p->indent_level)
822 warning_with_file_and_line
823 (p->name, old_lineno,
824 "This file contains more `%c's than `%c's.",
825 indent_level > p->indent_level ? '{' : '}',
826 indent_level > p->indent_level ? '}' : '{');
828 input_file_stack = p->next;
830 input_file_stack_tick++;
831 debug_end_source_file (input_file_stack->line);
834 error ("#-lines for entering and leaving files don't match");
837 /* Now that we've pushed or popped the input stack,
838 update the name in the top element. */
839 if (input_file_stack)
840 input_file_stack->name = input_filename;
842 /* skip the rest of this line. */
849 while (c != '\n' && c != EOF);
853 #ifdef HANDLE_GENERIC_PRAGMAS
855 /* Handle a #pragma directive.
856 TOKEN is the token we read after `#pragma'. Processes the entire input
857 line and return non-zero iff the pragma has been successfully parsed. */
859 /* This function has to be in this file, in order to get at
863 handle_generic_pragma (token)
874 handle_pragma_token (token_buffer, yylval.ttype);
878 return handle_pragma_token (NULL_PTR, NULL_TREE);
881 handle_pragma_token (token_buffer, NULL);
888 #endif /* HANDLE_GENERIC_PRAGMAS */
890 #define ENDFILE -1 /* token that represents end-of-file */
892 /* Read an escape sequence, returning its equivalent as a character,
893 or store 1 in *ignore_ptr if it is backslash-newline. */
896 readescape (ignore_ptr)
899 register int c = GETC();
901 register unsigned count;
902 unsigned firstdig = 0;
908 if (warn_traditional)
909 warning ("the meaning of `\\x' varies with -traditional");
911 if (flag_traditional)
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)
942 warning ("\\x used with no following hex digits");
946 /* Digits are all 0's. Ok. */
948 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
951 << (TYPE_PRECISION (integer_type_node)
954 pedwarn ("hex escape out of range");
957 case '0': case '1': case '2': case '3': case '4':
958 case '5': case '6': case '7':
961 while ((c <= '7') && (c >= '0') && (count++ < 3))
963 code = (code * 8) + (c - '0');
969 case '\\': case '\'': case '"':
978 return TARGET_NEWLINE;
993 if (warn_traditional)
994 warning ("the meaning of `\\a' varies with -traditional");
996 if (flag_traditional)
1001 #if 0 /* Vertical tab is present in common usage compilers. */
1002 if (flag_traditional)
1010 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
1016 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
1020 /* `\%' is used to prevent SCCS from getting confused. */
1023 pedwarn ("unknown escape sequence `\\%c'", c);
1027 pedwarn ("unknown escape sequence `\\%c'", c);
1029 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
1037 const char *string = _(msgid);
1039 /* We can't print string and character constants well
1040 because the token_buffer contains the result of processing escapes. */
1042 error ("%s at end of input", string);
1043 else if (token_buffer[0] == 0)
1044 error ("%s at null character", string);
1045 else if (token_buffer[0] == '"')
1046 error ("%s before string constant", string);
1047 else if (token_buffer[0] == '\'')
1048 error ("%s before character constant", string);
1049 else if (!ISGRAPH(token_buffer[0]))
1050 error ("%s before character 0%o", string, (unsigned char) token_buffer[0]);
1052 error ("%s before `%s'", string, 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 int conversion_errno;
1087 REAL_VALUE_TYPE value;
1094 struct pf_args * args = (struct pf_args *) data;
1095 int fflag = 0, lflag = 0;
1096 /* Copy token_buffer now, while it has just the number
1097 and not the suffixes; once we add `f' or `i',
1098 REAL_VALUE_ATOF may not work any more. */
1099 char *copy = (char *) alloca (args->p - token_buffer + 1);
1100 bcopy (token_buffer, copy, args->p - token_buffer + 1);
1102 args->conversion_errno = 0;
1103 args->type = double_type_node;
1109 /* Read the suffixes to choose a data type. */
1114 error ("more than one `f' in numeric constant");
1120 error ("more than one `l' in numeric constant");
1126 error ("more than one `i' or `j' in numeric constant");
1128 pedwarn ("ANSI C forbids imaginary numeric constants");
1139 if (args->p >= token_buffer + maxtoken - 3)
1140 args->p = extend_token_buffer (args->p);
1141 *(args->p++) = args->c;
1146 /* The second argument, machine_mode, of REAL_VALUE_ATOF
1147 tells the desired precision of the binary result
1148 of decimal-to-binary conversion. */
1153 error ("both `f' and `l' in floating constant");
1155 args->type = float_type_node;
1157 if (args->base == 16)
1158 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
1160 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
1161 args->conversion_errno = errno;
1162 /* A diagnostic is required here by some ANSI C testsuites.
1163 This is not pedwarn, because some people don't want
1164 an error for this. */
1165 if (REAL_VALUE_ISINF (args->value) && pedantic)
1166 warning ("floating point number exceeds range of `float'");
1170 args->type = long_double_type_node;
1172 if (args->base == 16)
1173 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
1175 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
1176 args->conversion_errno = errno;
1177 if (REAL_VALUE_ISINF (args->value) && pedantic)
1178 warning ("floating point number exceeds range of `long double'");
1183 if (args->base == 16)
1184 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
1186 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
1187 args->conversion_errno = errno;
1188 if (REAL_VALUE_ISINF (args->value) && pedantic)
1189 warning ("floating point number exceeds range of `double'");
1193 /* Get the next character, staying within the current token if possible.
1194 If we're lexing a token, we don't want to look beyond the end of the
1195 token cpplib has prepared for us; otherwise, we end up reading in the
1196 next token, which screws up feed_input. So just return a null
1199 static inline int token_getch PARAMS ((void));
1205 if (yy_cur == yy_lim)
1211 static inline void token_put_back PARAMS ((int));
1224 /* Read a single token from the input stream, and assign it lexical
1238 /* Effectively do c = skip_white_space (c)
1239 but do it faster in the usual cases. */
1249 if (cpp_token == CPP_HSPACE)
1250 c = yy_get_token ();
1257 /* Call skip_white_space so we can warn if appropriate. */
1262 c = skip_white_space (c);
1264 goto found_nonwhite;
1268 token_buffer[0] = c;
1269 token_buffer[1] = 0;
1271 /* yylloc.first_line = lineno; */
1277 token_buffer[0] = 0;
1279 value = END_OF_LINE;
1286 if (cpp_token == CPP_NAME)
1289 /* Capital L may start a wide-string or wide-character constant. */
1291 register int c = token_getch();
1300 goto string_constant;
1307 if (!doing_objc_thang)
1314 /* '@' may start a constant string object. */
1315 register int c = token_getch ();
1319 goto string_constant;
1322 /* Fall through to treat '@' as the start of an identifier. */
1325 case 'A': case 'B': case 'C': case 'D': case 'E':
1326 case 'F': case 'G': case 'H': case 'I': case 'J':
1327 case 'K': case 'M': case 'N': case 'O':
1328 case 'P': case 'Q': case 'R': case 'S': case 'T':
1329 case 'U': case 'V': case 'W': case 'X': case 'Y':
1331 case 'a': case 'b': case 'c': case 'd': case 'e':
1332 case 'f': case 'g': case 'h': case 'i': case 'j':
1333 case 'k': case 'l': case 'm': case 'n': case 'o':
1334 case 'p': case 'q': case 'r': case 's': case 't':
1335 case 'u': case 'v': case 'w': case 'x': case 'y':
1341 if (cpp_token == CPP_NAME)
1343 /* Note that one character has already been read from
1344 yy_cur into token_buffer. Also, cpplib complains about
1345 $ in identifiers, so we don't have to. */
1347 int len = yy_lim - yy_cur + 1;
1348 if (len >= maxtoken)
1349 extend_token_buffer_to (len + 1);
1350 memcpy (token_buffer + 1, yy_cur, len);
1351 p = token_buffer + len;
1358 while (ISALNUM (c) || c == '_' || c == '$' || c == '@')
1360 /* Make sure this char really belongs in an identifier. */
1363 if (! dollars_in_ident)
1364 error ("`$' in identifier");
1366 pedwarn ("`$' in identifier");
1369 if (p >= token_buffer + maxtoken)
1370 p = extend_token_buffer (p);
1383 /* Try to recognize a keyword. Uses minimum-perfect hash function */
1386 register struct resword *ptr;
1388 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
1391 yylval.ttype = ridpointers[(int) ptr->rid];
1392 value = (int) ptr->token;
1394 /* Only return OBJECTNAME if it is a typedef. */
1395 if (doing_objc_thang && value == OBJECTNAME)
1397 tree decl = lookup_name(yylval.ttype);
1399 if (decl == NULL_TREE
1400 || TREE_CODE (decl) != TYPE_DECL)
1404 /* Even if we decided to recognize asm, still perhaps warn. */
1406 && (value == ASM_KEYWORD || value == TYPEOF
1407 || ptr->rid == RID_INLINE)
1408 && token_buffer[0] != '_')
1409 pedwarn ("ANSI does not permit the keyword `%s'",
1414 /* If we did not find a keyword, look for an identifier
1417 if (value == IDENTIFIER)
1421 if (token_buffer[0] == '@')
1422 error("invalid identifier `%s'", token_buffer);
1424 yylval.ttype = get_identifier (token_buffer);
1425 decl = lookup_name (yylval.ttype);
1427 if (decl != 0 && TREE_CODE (decl) == TYPE_DECL)
1429 /* A user-invisible read-only initialized variable
1430 should be replaced by its value.
1431 We handle only strings since that's the only case used in C. */
1432 else if (decl != 0 && TREE_CODE (decl) == VAR_DECL
1433 && DECL_IGNORED_P (decl)
1434 && TREE_READONLY (decl)
1435 && DECL_INITIAL (decl) != 0
1436 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
1438 tree stringval = DECL_INITIAL (decl);
1440 /* Copy the string value so that we won't clobber anything
1441 if we put something in the TREE_CHAIN of this one. */
1442 yylval.ttype = build_string (TREE_STRING_LENGTH (stringval),
1443 TREE_STRING_POINTER (stringval));
1446 else if (doing_objc_thang)
1448 tree objc_interface_decl = is_class_name (yylval.ttype);
1450 if (objc_interface_decl)
1453 yylval.ttype = objc_interface_decl;
1462 if (yy_cur < yy_lim)
1465 /* It's hard to preserve tokenization on '.' because
1466 it could be a symbol by itself, or it could be the
1467 start of a floating point number and cpp won't tell us. */
1468 register int c1 = token_getch ();
1469 token_buffer[1] = c1;
1472 c1 = token_getch ();
1475 token_buffer[2] = c1;
1476 token_buffer[3] = 0;
1480 error ("parse error at `..'");
1484 token_put_back (c1);
1487 token_put_back (c1);
1490 token_buffer[1] = 0;
1494 /* Optimize for most frequent case. */
1499 cond = (yy_cur == yy_lim);
1501 register int c1 = token_getch ();
1502 token_put_back (c1);
1503 cond = (! ISALNUM (c1) && c1 != '.');
1507 yylval.ttype = (c == '0') ? integer_zero_node : integer_one_node;
1513 case '2': case '3': case '4':
1514 case '5': case '6': case '7': case '8': case '9':
1519 int largest_digit = 0;
1523 /* We actually store only HOST_BITS_PER_CHAR bits in each part.
1524 The code below which fills the parts array assumes that a host
1525 int is at least twice as wide as a host char, and that
1526 HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
1527 Two HOST_WIDE_INTs is the largest int literal we can store.
1528 In order to detect overflow below, the number of parts (TOTAL_PARTS)
1529 must be exactly the number of parts needed to hold the bits
1530 of two HOST_WIDE_INTs. */
1531 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
1532 unsigned int parts[TOTAL_PARTS];
1534 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON}
1535 floatflag = NOT_FLOAT;
1537 for (count = 0; count < TOTAL_PARTS; count++)
1545 *p++ = (c = token_getch());
1546 if ((c == 'x') || (c == 'X'))
1549 *p++ = (c = token_getch());
1551 /* Leading 0 forces octal unless the 0 is the only digit. */
1552 else if (c >= '0' && c <= '9')
1561 /* Read all the digits-and-decimal-points. */
1564 || (ISALNUM (c) && c != 'l' && c != 'L'
1565 && c != 'u' && c != 'U'
1566 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
1567 && (floatflag == NOT_FLOAT
1568 || ((base != 16) && (c != 'f') && (c != 'F'))
1573 if (base == 16 && pedantic)
1574 pedwarn ("floating constant may not be in radix 16");
1575 if (floatflag == TOO_MANY_POINTS)
1576 /* We have already emitted an error. Don't need another. */
1578 else if (floatflag == AFTER_POINT || floatflag == AFTER_EXPON)
1580 error ("malformed floating constant");
1581 floatflag = TOO_MANY_POINTS;
1582 /* Avoid another error from atof by forcing all characters
1583 from here on to be ignored. */
1587 floatflag = AFTER_POINT;
1591 *p++ = c = token_getch();
1592 /* Accept '.' as the start of a floating-point number
1593 only when it is followed by a digit. */
1594 if (p == token_buffer + 2 && !ISDIGIT (c))
1599 /* It is not a decimal point.
1600 It should be a digit (perhaps a hex digit). */
1606 else if (base <= 10)
1608 if (c == 'e' || c == 'E')
1611 floatflag = AFTER_EXPON;
1612 break; /* start of exponent */
1614 error ("nondigits in number and not hexadecimal");
1617 else if (base == 16 && (c == 'p' || c == 'P'))
1619 floatflag = AFTER_EXPON;
1620 break; /* start of exponent */
1622 else if (c >= 'a' && c <= 'f')
1630 if (c >= largest_digit)
1634 for (count = 0; count < TOTAL_PARTS; count++)
1636 parts[count] *= base;
1640 += (parts[count-1] >> HOST_BITS_PER_CHAR);
1642 &= (1 << HOST_BITS_PER_CHAR) - 1;
1648 /* If the highest-order part overflows (gets larger than
1649 a host char will hold) then the whole number has
1650 overflowed. Record this and truncate the highest-order
1652 if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
1655 parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
1658 if (p >= token_buffer + maxtoken - 3)
1659 p = extend_token_buffer (p);
1660 *p++ = (c = token_getch());
1664 /* This can happen on input like `int i = 0x;' */
1666 error ("numeric constant with no digits");
1668 if (largest_digit >= base)
1669 error ("numeric constant contains digits beyond the radix");
1671 /* Remove terminating char from the token buffer and delimit the
1675 if (floatflag != NOT_FLOAT)
1678 int imag, conversion_errno;
1679 REAL_VALUE_TYPE value;
1680 struct pf_args args;
1682 /* Read explicit exponent if any, and put it in tokenbuf. */
1684 if ((base == 10 && ((c == 'e') || (c == 'E')))
1685 || (base == 16 && (c == 'p' || c == 'P')))
1687 if (p >= token_buffer + maxtoken - 3)
1688 p = extend_token_buffer (p);
1691 if ((c == '+') || (c == '-'))
1696 /* Exponent is decimal, even if string is a hex float. */
1698 error ("floating constant exponent has no digits");
1701 if (p >= token_buffer + maxtoken - 3)
1702 p = extend_token_buffer (p);
1707 if (base == 16 && floatflag != AFTER_EXPON)
1708 error ("hexadecimal floating constant has no exponent");
1712 /* Setup input for parse_float() */
1717 /* Convert string to a double, checking for overflow. */
1718 if (do_float_handler (parse_float, (PTR) &args))
1720 /* Receive output from parse_float() */
1725 /* We got an exception from parse_float() */
1726 error ("floating constant out of range");
1730 /* Receive output from parse_float() */
1734 conversion_errno = args.conversion_errno;
1737 /* ERANGE is also reported for underflow,
1738 so test the value to distinguish overflow from that. */
1739 if (conversion_errno == ERANGE && !flag_traditional && pedantic
1740 && (REAL_VALUES_LESS (dconst1, value)
1741 || REAL_VALUES_LESS (value, dconstm1)))
1742 warning ("floating point number exceeds range of `double'");
1745 /* If the result is not a number, assume it must have been
1746 due to some error message above, so silently convert
1748 if (REAL_VALUE_ISNAN (value))
1751 /* Create a node with determined type and value. */
1753 yylval.ttype = build_complex (NULL_TREE,
1754 convert (type, integer_zero_node),
1755 build_real (type, value));
1757 yylval.ttype = build_real (type, value);
1761 tree traditional_type, ansi_type, type;
1762 HOST_WIDE_INT high, low;
1763 int spec_unsigned = 0;
1765 int spec_long_long = 0;
1769 traditional_type = ansi_type = type = NULL_TREE;
1772 if (c == 'u' || c == 'U')
1775 error ("two `u's in integer constant");
1778 else if (c == 'l' || c == 'L')
1783 error ("three `l's in integer constant");
1784 else if (pedantic && ! flag_isoc99
1785 && ! in_system_header && warn_long_long)
1786 pedwarn ("ANSI C forbids long long integer constants");
1791 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
1794 error ("more than one `i' or `j' in numeric constant");
1796 pedwarn ("ANSI C forbids imaginary numeric constants");
1801 if (p >= token_buffer + maxtoken - 3)
1802 p = extend_token_buffer (p);
1807 /* If the literal overflowed, pedwarn about it now. */
1811 pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
1814 /* This is simplified by the fact that our constant
1815 is always positive. */
1819 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1821 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1822 / HOST_BITS_PER_CHAR)]
1823 << (i * HOST_BITS_PER_CHAR));
1824 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1827 yylval.ttype = build_int_2 (low, high);
1828 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1830 /* If warn_traditional, calculate both the ANSI type and the
1831 traditional type, then see if they disagree.
1832 Otherwise, calculate only the type for the dialect in use. */
1833 if (warn_traditional || flag_traditional)
1835 /* Calculate the traditional type. */
1836 /* Traditionally, any constant is signed;
1837 but if unsigned is specified explicitly, obey that.
1838 Use the smallest size with the right number of bits,
1839 except for one special case with decimal constants. */
1840 if (! spec_long && base != 10
1841 && int_fits_type_p (yylval.ttype, unsigned_type_node))
1842 traditional_type = (spec_unsigned ? unsigned_type_node
1843 : integer_type_node);
1844 /* A decimal constant must be long
1845 if it does not fit in type int.
1846 I think this is independent of whether
1847 the constant is signed. */
1848 else if (! spec_long && base == 10
1849 && int_fits_type_p (yylval.ttype, integer_type_node))
1850 traditional_type = (spec_unsigned ? unsigned_type_node
1851 : integer_type_node);
1852 else if (! spec_long_long)
1853 traditional_type = (spec_unsigned ? long_unsigned_type_node
1854 : long_integer_type_node);
1855 else if (int_fits_type_p (yylval.ttype,
1857 ? long_long_unsigned_type_node
1858 : long_long_integer_type_node))
1859 traditional_type = (spec_unsigned
1860 ? long_long_unsigned_type_node
1861 : long_long_integer_type_node);
1863 traditional_type = (spec_unsigned
1864 ? widest_unsigned_literal_type_node
1865 : widest_integer_literal_type_node);
1867 if (warn_traditional || ! flag_traditional)
1869 /* Calculate the ANSI type. */
1870 if (! spec_long && ! spec_unsigned
1871 && int_fits_type_p (yylval.ttype, integer_type_node))
1872 ansi_type = integer_type_node;
1873 else if (! spec_long && (base != 10 || spec_unsigned)
1874 && int_fits_type_p (yylval.ttype, unsigned_type_node))
1875 ansi_type = unsigned_type_node;
1876 else if (! spec_unsigned && !spec_long_long
1877 && int_fits_type_p (yylval.ttype, long_integer_type_node))
1878 ansi_type = long_integer_type_node;
1879 else if (! spec_long_long
1880 && int_fits_type_p (yylval.ttype,
1881 long_unsigned_type_node))
1882 ansi_type = long_unsigned_type_node;
1883 else if (! spec_unsigned
1884 && int_fits_type_p (yylval.ttype,
1885 long_long_integer_type_node))
1886 ansi_type = long_long_integer_type_node;
1887 else if (int_fits_type_p (yylval.ttype,
1888 long_long_unsigned_type_node))
1889 ansi_type = long_long_unsigned_type_node;
1890 else if (! spec_unsigned
1891 && int_fits_type_p (yylval.ttype,
1892 widest_integer_literal_type_node))
1893 ansi_type = widest_integer_literal_type_node;
1895 ansi_type = widest_unsigned_literal_type_node;
1898 type = flag_traditional ? traditional_type : ansi_type;
1900 /* We assume that constants specified in a non-decimal
1901 base are bit patterns, and that the programmer really
1902 meant what they wrote. */
1903 if (warn_traditional && base == 10
1904 && traditional_type != ansi_type)
1906 if (TYPE_PRECISION (traditional_type)
1907 != TYPE_PRECISION (ansi_type))
1908 warning ("width of integer constant changes with -traditional");
1909 else if (TREE_UNSIGNED (traditional_type)
1910 != TREE_UNSIGNED (ansi_type))
1911 warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1913 warning ("width of integer constant may change on other systems with -traditional");
1916 if (pedantic && !flag_traditional && !spec_long_long && !warn
1917 && (TYPE_PRECISION (long_integer_type_node)
1918 < TYPE_PRECISION (type)))
1921 pedwarn ("integer constant larger than the maximum value of an unsigned long int");
1924 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1925 warning ("decimal constant is so large that it is unsigned");
1929 if (TYPE_PRECISION (type)
1930 <= TYPE_PRECISION (integer_type_node))
1932 = build_complex (NULL_TREE, integer_zero_node,
1933 convert (integer_type_node,
1936 error ("complex integer constant is too wide for `complex int'");
1938 else if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1939 /* The traditional constant 0x80000000 is signed
1940 but doesn't fit in the range of int.
1941 This will change it to -0x80000000, which does fit. */
1943 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1944 yylval.ttype = convert (type, yylval.ttype);
1945 TREE_OVERFLOW (yylval.ttype)
1946 = TREE_CONSTANT_OVERFLOW (yylval.ttype) = 0;
1949 TREE_TYPE (yylval.ttype) = type;
1952 /* If it's still an integer (not a complex), and it doesn't
1953 fit in the type we choose for it, then pedwarn. */
1956 && TREE_CODE (TREE_TYPE (yylval.ttype)) == INTEGER_TYPE
1957 && ! int_fits_type_p (yylval.ttype, TREE_TYPE (yylval.ttype)))
1958 pedwarn ("integer constant is larger than the maximum value for its type");
1964 if (ISALNUM (c) || c == '.' || c == '_' || c == '$'
1965 || (!flag_traditional && (c == '-' || c == '+')
1966 && (p[-1] == 'e' || p[-1] == 'E')))
1967 error ("missing white space after number `%s'", token_buffer);
1969 value = CONSTANT; break;
1975 register int result = 0;
1976 register int num_chars = 0;
1978 unsigned width = TYPE_PRECISION (char_type_node);
1980 #ifdef MULTIBYTE_CHARS
1981 int longest_char = local_mb_cur_max ();
1982 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
1985 max_chars = TYPE_PRECISION (integer_type_node) / width;
1987 width = WCHAR_TYPE_SIZE;
1994 if (c == '\'' || c == EOF)
2001 c = readescape (&ignore);
2004 if (width < HOST_BITS_PER_INT
2005 && (unsigned) c >= ((unsigned)1 << width))
2006 pedwarn ("escape sequence out of range for character");
2007 #ifdef MAP_CHARACTER
2009 c = MAP_CHARACTER (c);
2015 pedwarn ("ANSI C forbids newline in character constant");
2020 #ifdef MULTIBYTE_CHARS
2024 for (i = 1; i <= longest_char; ++i)
2026 if (i > maxtoken - 4)
2027 extend_token_buffer (token_buffer);
2029 token_buffer[i] = c;
2030 char_len = local_mbtowc (& wc,
2039 /* mbtowc sometimes needs an extra char before accepting */
2044 /* Merge character into result; ignore excess chars. */
2045 for (i = 1; i <= char_len; ++i)
2049 if (width < HOST_BITS_PER_INT)
2050 result = (result << width)
2052 & ((1 << width) - 1));
2054 result = token_buffer[i];
2056 num_chars += char_len;
2065 warning ("Ignoring invalid multibyte character");
2066 /* Replace all but the first byte. */
2067 for (--i; i > 1; --i)
2068 token_put_back (token_buffer[i]);
2069 wc = token_buffer[1];
2071 #ifdef MAP_CHARACTER
2072 c = MAP_CHARACTER (wc);
2077 #else /* ! MULTIBYTE_CHARS */
2078 #ifdef MAP_CHARACTER
2079 c = MAP_CHARACTER (c);
2081 #endif /* ! MULTIBYTE_CHARS */
2086 if (chars_seen == 1) /* only keep the first one */
2091 /* Merge character into result; ignore excess chars. */
2092 num_chars += (width / TYPE_PRECISION (char_type_node));
2093 if (num_chars < max_chars + 1)
2095 if (width < HOST_BITS_PER_INT)
2096 result = (result << width) | (c & ((1 << width) - 1));
2103 error ("malformed character constant");
2104 else if (chars_seen == 0)
2105 error ("empty character constant");
2106 else if (num_chars > max_chars)
2108 num_chars = max_chars;
2109 error ("character constant too long");
2111 else if (chars_seen != 1 && ! flag_traditional && warn_multichar)
2112 warning ("multi-character character constant");
2114 /* If char type is signed, sign-extend the constant. */
2117 int num_bits = num_chars * width;
2119 /* We already got an error; avoid invalid shift. */
2120 yylval.ttype = build_int_2 (0, 0);
2121 else if (TREE_UNSIGNED (char_type_node)
2122 || ((result >> (num_bits - 1)) & 1) == 0)
2124 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
2125 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
2129 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
2130 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
2132 TREE_TYPE (yylval.ttype) = integer_type_node;
2136 yylval.ttype = build_int_2 (result, 0);
2137 TREE_TYPE (yylval.ttype) = wchar_type_node;
2147 unsigned width = wide_flag ? WCHAR_TYPE_SIZE
2148 : TYPE_PRECISION (char_type_node);
2149 #ifdef MULTIBYTE_CHARS
2150 int longest_char = local_mb_cur_max ();
2151 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
2154 p = token_buffer + 1;
2156 while (c != '"' && c != EOF)
2158 /* ignore_escape_flag is set for reading the filename in #line. */
2159 if (!ignore_escape_flag && c == '\\')
2162 c = readescape (&ignore);
2165 if (width < HOST_BITS_PER_INT
2166 && (unsigned) c >= ((unsigned)1 << width))
2167 pedwarn ("escape sequence out of range for character");
2172 pedwarn ("ANSI C forbids newline in string constant");
2177 #ifdef MULTIBYTE_CHARS
2181 for (i = 0; i < longest_char; ++i)
2183 if (p + i >= token_buffer + maxtoken)
2184 p = extend_token_buffer (p);
2187 char_len = local_mbtowc (& wc, p, i + 1);
2194 warning ("Ignoring invalid multibyte character");
2195 /* Replace all except the first byte. */
2197 for (--i; i > 0; --i)
2198 token_put_back (p[i]);
2201 /* mbtowc sometimes needs an extra char before accepting */
2211 #endif /* MULTIBYTE_CHARS */
2214 /* Add this single character into the buffer either as a wchar_t
2215 or as a single byte. */
2218 unsigned width = TYPE_PRECISION (char_type_node);
2219 unsigned bytemask = (1 << width) - 1;
2222 if (p + WCHAR_BYTES > token_buffer + maxtoken)
2223 p = extend_token_buffer (p);
2225 for (byte = 0; byte < WCHAR_BYTES; ++byte)
2228 if (byte >= (int) sizeof (c))
2231 value = (c >> (byte * width)) & bytemask;
2232 if (BYTES_BIG_ENDIAN)
2233 p[WCHAR_BYTES - byte - 1] = value;
2241 if (p >= token_buffer + maxtoken)
2242 p = extend_token_buffer (p);
2250 /* Terminate the string value, either with a single byte zero
2251 or with a wide zero. */
2254 if (p + WCHAR_BYTES > token_buffer + maxtoken)
2255 p = extend_token_buffer (p);
2256 bzero (p, WCHAR_BYTES);
2261 if (p >= token_buffer + maxtoken)
2262 p = extend_token_buffer (p);
2267 error ("Unterminated string constant");
2269 /* We have read the entire constant.
2270 Construct a STRING_CST for the result. */
2274 yylval.ttype = build_string (p - (token_buffer + 1),
2276 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
2281 /* Return an Objective-C @"..." constant string object. */
2282 yylval.ttype = build_objc_string (p - (token_buffer + 1),
2284 TREE_TYPE (yylval.ttype) = char_array_type_node;
2285 value = OBJC_STRING;
2289 yylval.ttype = build_string (p - (token_buffer + 1),
2291 TREE_TYPE (yylval.ttype) = char_array_type_node;
2319 yylval.code = PLUS_EXPR; break;
2321 yylval.code = MINUS_EXPR; break;
2323 yylval.code = BIT_AND_EXPR; break;
2325 yylval.code = BIT_IOR_EXPR; break;
2327 yylval.code = MULT_EXPR; break;
2329 yylval.code = TRUNC_DIV_EXPR; break;
2331 yylval.code = TRUNC_MOD_EXPR; break;
2333 yylval.code = BIT_XOR_EXPR; break;
2335 yylval.code = LSHIFT_EXPR; break;
2337 yylval.code = RSHIFT_EXPR; break;
2339 yylval.code = LT_EXPR; break;
2341 yylval.code = GT_EXPR; break;
2344 token_buffer[1] = c1 = token_getch();
2345 token_buffer[2] = 0;
2352 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
2354 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
2356 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
2358 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
2360 value = ASSIGN; goto done;
2366 value = PLUSPLUS; goto done;
2368 value = MINUSMINUS; goto done;
2370 value = ANDAND; goto done;
2372 value = OROR; goto done;
2385 { value = POINTSAT; goto done; }
2391 { value = ']'; goto done; }
2395 { value = '{'; indent_level++; goto done; }
2397 { value = '['; goto done; }
2401 { value = '}'; indent_level--; goto done; }
2405 token_put_back (c1);
2406 token_buffer[1] = 0;
2408 if ((c == '<') || (c == '>'))
2409 value = ARITHCOMPARE;
2415 /* Don't make yyparse think this is eof. */
2434 /* yylloc.last_line = lineno; */
2439 /* Sets the value of the 'yydebug' variable to VALUE.
2440 This is a function so we don't have to have YYDEBUG defined
2441 in order to build the compiler. */
2450 warning ("YYDEBUG not defined.");