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. */
34 #ifdef MULTIBYTE_CHARS
43 /* The elements of `ridpointers' are identifier nodes
44 for the reserved type names and storage classes.
45 It is indexed by a RID_... value. */
46 tree ridpointers
[(int) RID_MAX
];
48 /* Cause the `yydebug' variable to be defined. */
51 /* the declaration found for the last IDENTIFIER token read in.
52 yylex must look this up to detect typedefs, which get token type TYPENAME,
53 so it is left around in case the identifier is not a typedef but is
54 used in a context which makes it a reference to a variable. */
57 /* Nonzero enables objc features. */
61 extern tree
is_class_name ();
65 /* File used for outputting assembler code. */
66 extern FILE *asm_out_file
;
68 #ifndef WCHAR_TYPE_SIZE
70 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
72 #define WCHAR_TYPE_SIZE BITS_PER_WORD
76 /* Number of bytes in a wide character. */
77 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
79 static int maxtoken
; /* Current nominal length of token buffer. */
80 char *token_buffer
; /* Pointer to token buffer.
81 Actual allocated length is maxtoken + 2.
82 This is not static because objc-parse.y uses it. */
84 /* Nonzero if end-of-file has been seen on input. */
85 static int end_of_file
;
87 /* Buffered-back input character; faster than using ungetc. */
88 static int nextchar
= -1;
92 /* Nonzero tells yylex to ignore \ in string constants. */
93 static int ignore_escape_flag
= 0;
95 /* C code produced by gperf version 2.5 (GNU C++ version) */
96 /* Command-line: gperf -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ c-parse.gperf */
97 struct resword
{ char *name
; short token
; enum rid rid
; };
99 #define TOTAL_KEYWORDS 79
100 #define MIN_WORD_LENGTH 2
101 #define MAX_WORD_LENGTH 20
102 #define MIN_HASH_VALUE 10
103 #define MAX_HASH_VALUE 144
104 /* maximum key range = 135, duplicates = 0 */
112 register int unsigned len
;
114 static unsigned char asso_values
[] =
116 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
117 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
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, 25, 145, 145, 145, 145, 145,
123 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
124 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
125 145, 145, 145, 145, 145, 1, 145, 46, 8, 15,
126 61, 6, 36, 48, 3, 5, 145, 18, 63, 25,
127 29, 76, 1, 145, 13, 2, 1, 51, 37, 9,
128 9, 1, 3, 145, 145, 145, 145, 145,
130 register int hval
= len
;
136 hval
+= asso_values
[str
[2]];
139 hval
+= asso_values
[str
[0]];
141 return hval
+ asso_values
[str
[len
- 1]];
144 static struct resword wordlist
[] =
146 {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
148 {"int", TYPESPEC
, RID_INT
},
150 {"__typeof__", TYPEOF
, NORID
},
151 {"__signed__", TYPESPEC
, RID_SIGNED
},
152 {"__imag__", IMAGPART
, NORID
},
153 {"switch", SWITCH
, NORID
},
154 {"__inline__", SCSPEC
, RID_INLINE
},
155 {"else", ELSE
, NORID
},
156 {"__iterator__", SCSPEC
, RID_ITERATOR
},
157 {"__inline", SCSPEC
, RID_INLINE
},
158 {"__extension__", EXTENSION
, NORID
},
159 {"struct", STRUCT
, NORID
},
160 {"__real__", REALPART
, NORID
},
161 {"__const", TYPE_QUAL
, RID_CONST
},
162 {"while", WHILE
, NORID
},
163 {"__const__", TYPE_QUAL
, RID_CONST
},
164 {"case", CASE
, NORID
},
165 {"__complex__", TYPESPEC
, RID_COMPLEX
},
166 {"__iterator", SCSPEC
, RID_ITERATOR
},
167 {"bycopy", TYPE_QUAL
, RID_BYCOPY
},
169 {"__complex", TYPESPEC
, RID_COMPLEX
},
171 {"in", TYPE_QUAL
, RID_IN
},
172 {"break", BREAK
, NORID
},
173 {"@defs", DEFS
, NORID
},
175 {"extern", SCSPEC
, RID_EXTERN
},
177 {"typeof", TYPEOF
, NORID
},
178 {"typedef", SCSPEC
, RID_TYPEDEF
},
179 {"__typeof", TYPEOF
, NORID
},
180 {"sizeof", SIZEOF
, NORID
},
182 {"return", RETURN
, NORID
},
183 {"const", TYPE_QUAL
, RID_CONST
},
184 {"__volatile__", TYPE_QUAL
, RID_VOLATILE
},
185 {"@private", PRIVATE
, NORID
},
186 {"@selector", SELECTOR
, NORID
},
187 {"__volatile", TYPE_QUAL
, RID_VOLATILE
},
188 {"__asm__", ASM_KEYWORD
, NORID
},
190 {"continue", CONTINUE
, NORID
},
191 {"__alignof__", ALIGNOF
, NORID
},
192 {"__imag", IMAGPART
, NORID
},
193 {"__attribute__", ATTRIBUTE
, NORID
},
195 {"__attribute", ATTRIBUTE
, NORID
},
198 {"@encode", ENCODE
, NORID
},
199 {"id", OBJECTNAME
, RID_ID
},
200 {"static", SCSPEC
, RID_STATIC
},
201 {"@interface", INTERFACE
, NORID
},
203 {"__signed", TYPESPEC
, RID_SIGNED
},
205 {"__label__", LABEL
, NORID
},
207 {"__asm", ASM_KEYWORD
, NORID
},
208 {"char", TYPESPEC
, RID_CHAR
},
210 {"inline", SCSPEC
, RID_INLINE
},
211 {"out", TYPE_QUAL
, RID_OUT
},
212 {"register", SCSPEC
, RID_REGISTER
},
213 {"__real", REALPART
, NORID
},
214 {"short", TYPESPEC
, RID_SHORT
},
216 {"enum", ENUM
, NORID
},
217 {"inout", TYPE_QUAL
, RID_INOUT
},
219 {"oneway", TYPE_QUAL
, RID_ONEWAY
},
220 {"union", UNION
, NORID
},
222 {"__alignof", ALIGNOF
, NORID
},
224 {"@implementation", IMPLEMENTATION
, NORID
},
226 {"@class", CLASS
, NORID
},
228 {"@public", PUBLIC
, NORID
},
229 {"asm", ASM_KEYWORD
, NORID
},
230 {"",}, {"",}, {"",}, {"",}, {"",},
231 {"default", DEFAULT
, NORID
},
233 {"void", TYPESPEC
, RID_VOID
},
235 {"@protected", PROTECTED
, NORID
},
236 {"@protocol", PROTOCOL
, NORID
},
238 {"volatile", TYPE_QUAL
, RID_VOLATILE
},
240 {"signed", TYPESPEC
, RID_SIGNED
},
241 {"float", TYPESPEC
, RID_FLOAT
},
242 {"@end", END
, NORID
},
244 {"unsigned", TYPESPEC
, RID_UNSIGNED
},
245 {"@compatibility_alias", ALIAS
, NORID
},
246 {"double", TYPESPEC
, RID_DOUBLE
},
248 {"auto", SCSPEC
, RID_AUTO
},
250 {"goto", GOTO
, NORID
},
251 {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
253 {"",}, {"",}, {"",}, {"",},
254 {"long", TYPESPEC
, RID_LONG
},
261 is_reserved_word (str
, len
)
263 register unsigned int len
;
265 if (len
<= MAX_WORD_LENGTH
&& len
>= MIN_WORD_LENGTH
)
267 register int key
= hash (str
, len
);
269 if (key
<= MAX_HASH_VALUE
&& key
>= 0)
271 register char *s
= wordlist
[key
].name
;
273 if (*s
== *str
&& !strcmp (str
+ 1, s
+ 1))
274 return &wordlist
[key
];
280 /* Return something to represent absolute declarators containing a *.
281 TARGET is the absolute declarator that the * contains.
282 TYPE_QUALS is a list of modifiers such as const or volatile
283 to apply to the pointer type, represented as identifiers.
285 We return an INDIRECT_REF whose "contents" are TARGET
286 and whose type is the modifier list. */
289 make_pointer_declarator (type_quals
, target
)
290 tree type_quals
, target
;
292 return build1 (INDIRECT_REF
, type_quals
, target
);
296 forget_protocol_qualifiers ()
298 int i
, n
= sizeof wordlist
/ sizeof (struct resword
);
300 for (i
= 0; i
< n
; i
++)
301 if ((int) wordlist
[i
].rid
>= (int) RID_IN
302 && (int) wordlist
[i
].rid
<= (int) RID_ONEWAY
)
303 wordlist
[i
].name
= "";
307 remember_protocol_qualifiers ()
309 int i
, n
= sizeof wordlist
/ sizeof (struct resword
);
311 for (i
= 0; i
< n
; i
++)
312 if (wordlist
[i
].rid
== RID_IN
)
313 wordlist
[i
].name
= "in";
314 else if (wordlist
[i
].rid
== RID_OUT
)
315 wordlist
[i
].name
= "out";
316 else if (wordlist
[i
].rid
== RID_INOUT
)
317 wordlist
[i
].name
= "inout";
318 else if (wordlist
[i
].rid
== RID_BYCOPY
)
319 wordlist
[i
].name
= "bycopy";
320 else if (wordlist
[i
].rid
== RID_ONEWAY
)
321 wordlist
[i
].name
= "oneway";
327 /* Make identifier nodes long enough for the language-specific slots. */
328 set_identifier_size (sizeof (struct lang_identifier
));
330 /* Start it at 0, because check_newline is called at the very beginning
331 and will increment it to 1. */
334 #ifdef MULTIBYTE_CHARS
335 /* Change to the native locale for multibyte conversions. */
336 setlocale (LC_CTYPE
, "");
340 token_buffer
= (char *) xmalloc (maxtoken
+ 2);
342 ridpointers
[(int) RID_INT
] = get_identifier ("int");
343 ridpointers
[(int) RID_CHAR
] = get_identifier ("char");
344 ridpointers
[(int) RID_VOID
] = get_identifier ("void");
345 ridpointers
[(int) RID_FLOAT
] = get_identifier ("float");
346 ridpointers
[(int) RID_DOUBLE
] = get_identifier ("double");
347 ridpointers
[(int) RID_SHORT
] = get_identifier ("short");
348 ridpointers
[(int) RID_LONG
] = get_identifier ("long");
349 ridpointers
[(int) RID_UNSIGNED
] = get_identifier ("unsigned");
350 ridpointers
[(int) RID_SIGNED
] = get_identifier ("signed");
351 ridpointers
[(int) RID_INLINE
] = get_identifier ("inline");
352 ridpointers
[(int) RID_CONST
] = get_identifier ("const");
353 ridpointers
[(int) RID_VOLATILE
] = get_identifier ("volatile");
354 ridpointers
[(int) RID_AUTO
] = get_identifier ("auto");
355 ridpointers
[(int) RID_STATIC
] = get_identifier ("static");
356 ridpointers
[(int) RID_EXTERN
] = get_identifier ("extern");
357 ridpointers
[(int) RID_TYPEDEF
] = get_identifier ("typedef");
358 ridpointers
[(int) RID_REGISTER
] = get_identifier ("register");
359 ridpointers
[(int) RID_ITERATOR
] = get_identifier ("iterator");
360 ridpointers
[(int) RID_COMPLEX
] = get_identifier ("complex");
361 ridpointers
[(int) RID_ID
] = get_identifier ("id");
362 ridpointers
[(int) RID_IN
] = get_identifier ("in");
363 ridpointers
[(int) RID_OUT
] = get_identifier ("out");
364 ridpointers
[(int) RID_INOUT
] = get_identifier ("inout");
365 ridpointers
[(int) RID_BYCOPY
] = get_identifier ("bycopy");
366 ridpointers
[(int) RID_ONEWAY
] = get_identifier ("oneway");
367 forget_protocol_qualifiers();
369 /* Some options inhibit certain reserved words.
370 Clear those words out of the hash table so they won't be recognized. */
371 #define UNSET_RESERVED_WORD(STRING) \
372 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
373 if (s) s->name = ""; } while (0)
375 if (! doing_objc_thang
)
376 UNSET_RESERVED_WORD ("id");
378 if (flag_traditional
)
380 UNSET_RESERVED_WORD ("const");
381 UNSET_RESERVED_WORD ("volatile");
382 UNSET_RESERVED_WORD ("typeof");
383 UNSET_RESERVED_WORD ("signed");
384 UNSET_RESERVED_WORD ("inline");
385 UNSET_RESERVED_WORD ("iterator");
386 UNSET_RESERVED_WORD ("complex");
390 UNSET_RESERVED_WORD ("asm");
391 UNSET_RESERVED_WORD ("typeof");
392 UNSET_RESERVED_WORD ("inline");
393 UNSET_RESERVED_WORD ("iterator");
394 UNSET_RESERVED_WORD ("complex");
399 reinit_parse_for_function ()
403 /* Function used when yydebug is set, to print a token in more detail. */
406 yyprint (file
, yychar
, yylval
)
418 if (IDENTIFIER_POINTER (t
))
419 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
424 if (TREE_CODE (t
) == INTEGER_CST
)
426 #if HOST_BITS_PER_WIDE_INT == 64
427 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
433 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
439 TREE_INT_CST_HIGH (t
), TREE_INT_CST_LOW (t
));
445 /* If C is not whitespace, return C.
446 Otherwise skip whitespace and return first nonwhite char read. */
452 static int newline_warning
= 0;
458 /* We don't recognize comments here, because
459 cpp output can include / and * consecutively as operators.
460 Also, there's no need, since cpp removes all comments. */
463 c
= check_newline ();
475 /* ANSI C says the effects of a carriage return in a source file
477 if (pedantic
&& !newline_warning
)
479 warning ("carriage return in source file");
480 warning ("(we only warn about the first carriage return)");
491 error ("stray '\\' in program");
501 /* Skips all of the white space at the current location in the input file.
502 Must use and reset nextchar if it has the next character. */
505 position_after_white_space ()
510 c
= nextchar
, nextchar
= -1;
514 ungetc (skip_white_space (c
), finput
);
517 /* Make the token buffer longer, preserving the data in it.
518 P should point to just beyond the last valid character in the old buffer.
519 The value we return is a pointer to the new buffer
520 at a place corresponding to P. */
523 extend_token_buffer (p
)
526 int offset
= p
- token_buffer
;
528 maxtoken
= maxtoken
* 2 + 10;
529 token_buffer
= (char *) xrealloc (token_buffer
, maxtoken
+ 2);
531 return token_buffer
+ offset
;
534 /* At the beginning of a line, increment the line number
535 and process any #-directive on this line.
536 If the line is a #-directive, read the entire line and return a newline.
537 Otherwise, return the line's first non-whitespace character. */
547 /* Read first nonwhite char on the line. */
550 while (c
== ' ' || c
== '\t')
555 /* If not #, return it so caller will use it. */
559 /* Read first nonwhite char after the `#'. */
562 while (c
== ' ' || c
== '\t')
565 /* If a letter follows, then if the word here is `line', skip
566 it and ignore it; otherwise, ignore the line, with an error
567 if the word isn't `pragma', `ident', `define', or `undef'. */
569 if ((c
>= 'a' && c
<= 'z') || (c
>= 'A' && c
<= 'Z'))
573 if (getc (finput
) == 'r'
574 && getc (finput
) == 'a'
575 && getc (finput
) == 'g'
576 && getc (finput
) == 'm'
577 && getc (finput
) == 'a'
578 && ((c
= getc (finput
)) == ' ' || c
== '\t' || c
== '\n'))
580 #ifdef HANDLE_SYSV_PRAGMA
581 return handle_sysv_pragma (finput
, c
);
582 #endif /* HANDLE_SYSV_PRAGMA */
584 HANDLE_PRAGMA (finput
);
585 #endif /* HANDLE_PRAGMA */
592 if (getc (finput
) == 'e'
593 && getc (finput
) == 'f'
594 && getc (finput
) == 'i'
595 && getc (finput
) == 'n'
596 && getc (finput
) == 'e'
597 && ((c
= getc (finput
)) == ' ' || c
== '\t' || c
== '\n'))
599 #ifdef DWARF_DEBUGGING_INFO
600 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
)
601 && (write_symbols
== DWARF_DEBUG
))
602 dwarfout_define (lineno
, get_directive_line (finput
));
603 #endif /* DWARF_DEBUGGING_INFO */
609 if (getc (finput
) == 'n'
610 && getc (finput
) == 'd'
611 && getc (finput
) == 'e'
612 && getc (finput
) == 'f'
613 && ((c
= getc (finput
)) == ' ' || c
== '\t' || c
== '\n'))
615 #ifdef DWARF_DEBUGGING_INFO
616 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
)
617 && (write_symbols
== DWARF_DEBUG
))
618 dwarfout_undef (lineno
, get_directive_line (finput
));
619 #endif /* DWARF_DEBUGGING_INFO */
625 if (getc (finput
) == 'i'
626 && getc (finput
) == 'n'
627 && getc (finput
) == 'e'
628 && ((c
= getc (finput
)) == ' ' || c
== '\t'))
633 if (getc (finput
) == 'd'
634 && getc (finput
) == 'e'
635 && getc (finput
) == 'n'
636 && getc (finput
) == 't'
637 && ((c
= getc (finput
)) == ' ' || c
== '\t'))
639 /* #ident. The pedantic warning is now in cccp.c. */
641 /* Here we have just seen `#ident '.
642 A string constant should follow. */
644 while (c
== ' ' || c
== '\t')
647 /* If no argument, ignore the line. */
654 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
656 error ("invalid #ident");
662 #ifdef ASM_OUTPUT_IDENT
663 ASM_OUTPUT_IDENT (asm_out_file
, TREE_STRING_POINTER (yylval
.ttype
));
667 /* Skip the rest of this line. */
672 error ("undefined or invalid # directive");
677 /* Here we have either `#line' or `# <nonletter>'.
678 In either case, it should be a line number; a digit should follow. */
680 while (c
== ' ' || c
== '\t')
683 /* If the # is the only nonwhite char on the line,
684 just ignore it. Check the new newline. */
688 /* Something follows the #; read a token. */
693 if (token
== CONSTANT
694 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
696 int old_lineno
= lineno
;
698 /* subtract one, because it is the following line that
699 gets the specified number */
701 int l
= TREE_INT_CST_LOW (yylval
.ttype
) - 1;
703 /* Is this the last nonwhite stuff on the line? */
705 while (c
== ' ' || c
== '\t')
709 /* No more: store the line number and check following line. */
715 /* More follows: it must be a string constant (filename). */
717 /* Read the string constant, but don't treat \ as special. */
718 ignore_escape_flag
= 1;
720 ignore_escape_flag
= 0;
722 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
724 error ("invalid #line");
729 = (char *) permalloc (TREE_STRING_LENGTH (yylval
.ttype
) + 1);
730 strcpy (input_filename
, TREE_STRING_POINTER (yylval
.ttype
));
733 /* Each change of file name
734 reinitializes whether we are now in a system header. */
735 in_system_header
= 0;
737 if (main_input_filename
== 0)
738 main_input_filename
= input_filename
;
740 /* Is this the last nonwhite stuff on the line? */
742 while (c
== ' ' || c
== '\t')
746 /* Update the name in the top element of input_file_stack. */
747 if (input_file_stack
)
748 input_file_stack
->name
= input_filename
;
757 /* `1' after file name means entering new file.
758 `2' after file name means just left a file. */
760 if (token
== CONSTANT
761 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
763 if (TREE_INT_CST_LOW (yylval
.ttype
) == 1)
765 /* Pushing to a new file. */
767 = (struct file_stack
*) xmalloc (sizeof (struct file_stack
));
768 input_file_stack
->line
= old_lineno
;
769 p
->next
= input_file_stack
;
770 p
->name
= input_filename
;
771 input_file_stack
= p
;
772 input_file_stack_tick
++;
773 #ifdef DWARF_DEBUGGING_INFO
774 if (debug_info_level
== DINFO_LEVEL_VERBOSE
775 && write_symbols
== DWARF_DEBUG
)
776 dwarfout_start_new_source_file (input_filename
);
777 #endif /* DWARF_DEBUGGING_INFO */
781 else if (TREE_INT_CST_LOW (yylval
.ttype
) == 2)
783 /* Popping out of a file. */
784 if (input_file_stack
->next
)
786 struct file_stack
*p
= input_file_stack
;
787 input_file_stack
= p
->next
;
789 input_file_stack_tick
++;
790 #ifdef DWARF_DEBUGGING_INFO
791 if (debug_info_level
== DINFO_LEVEL_VERBOSE
792 && write_symbols
== DWARF_DEBUG
)
793 dwarfout_resume_previous_source_file (input_file_stack
->line
);
794 #endif /* DWARF_DEBUGGING_INFO */
797 error ("#-lines for entering and leaving files don't match");
803 /* Now that we've pushed or popped the input stack,
804 update the name in the top element. */
805 if (input_file_stack
)
806 input_file_stack
->name
= input_filename
;
808 /* If we have handled a `1' or a `2',
809 see if there is another number to read. */
812 /* Is this the last nonwhite stuff on the line? */
814 while (c
== ' ' || c
== '\t')
824 /* `3' after file name means this is a system header file. */
826 if (token
== CONSTANT
827 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
828 && TREE_INT_CST_LOW (yylval
.ttype
) == 3)
829 in_system_header
= 1;
832 error ("invalid #-line");
834 /* skip the rest of this line. */
838 while ((c
= getc (finput
)) != EOF
&& c
!= '\n');
842 #ifdef HANDLE_SYSV_PRAGMA
844 /* Handle a #pragma directive. INPUT is the current input stream,
845 and C is a character to reread. Processes the entire input line
846 and returns a character for the caller to reread: either \n or EOF. */
848 /* This function has to be in this file, in order to get at
852 handle_sysv_pragma (input
, c
)
858 while (c
== ' ' || c
== '\t')
860 if (c
== '\n' || c
== EOF
)
862 handle_pragma_token (0, 0);
872 handle_pragma_token (token_buffer
, yylval
.ttype
);
875 handle_pragma_token (token_buffer
, 0);
878 c
= nextchar
, nextchar
= -1;
884 #endif /* HANDLE_SYSV_PRAGMA */
886 #define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
887 #define isdigit(char) (char >= '0' && char <= '9')
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. */
1016 pedwarn ("non-ANSI escape sequence `\\%c'", c
);
1019 if (c
>= 040 && c
< 0177)
1020 pedwarn ("unknown escape sequence `\\%c'", c
);
1022 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c
);
1032 strcpy (buf
, string
);
1034 /* We can't print string and character constants well
1035 because the token_buffer contains the result of processing escapes. */
1037 strcat (buf
, " at end of input");
1038 else if (token_buffer
[0] == 0)
1039 strcat (buf
, " at null character");
1040 else if (token_buffer
[0] == '"')
1041 strcat (buf
, " before string constant");
1042 else if (token_buffer
[0] == '\'')
1043 strcat (buf
, " before character constant");
1044 else if (token_buffer
[0] < 040 || (unsigned char) token_buffer
[0] >= 0177)
1045 sprintf (buf
+ strlen (buf
), " before character 0%o",
1046 (unsigned char) token_buffer
[0]);
1048 strcat (buf
, " before `%s'");
1050 error (buf
, token_buffer
);
1060 char long_long_flag
;
1063 struct try_type type_sequence
[] =
1065 { &integer_type_node
, 0, 0, 0},
1066 { &unsigned_type_node
, 1, 0, 0},
1067 { &long_integer_type_node
, 0, 1, 0},
1068 { &long_unsigned_type_node
, 1, 1, 0},
1069 { &long_long_integer_type_node
, 0, 1, 1},
1070 { &long_long_unsigned_type_node
, 1, 1, 1}
1084 c
= nextchar
, nextchar
= -1;
1088 /* Effectively do c = skip_white_space (c)
1089 but do it faster in the usual cases. */
1102 /* Call skip_white_space so we can warn if appropriate. */
1107 c
= skip_white_space (c
);
1109 goto found_nonwhite
;
1113 token_buffer
[0] = c
;
1114 token_buffer
[1] = 0;
1116 /* yylloc.first_line = lineno; */
1122 token_buffer
[0] = 0;
1127 if (dollars_in_ident
)
1132 /* Capital L may start a wide-string or wide-character constant. */
1134 register int c
= getc (finput
);
1143 goto string_constant
;
1150 if (!doing_objc_thang
)
1157 /* '@' may start a constant string object. */
1158 register int c
= getc(finput
);
1162 goto string_constant
;
1165 /* Fall through to treat '@' as the start of an indentifier. */
1168 case 'A': case 'B': case 'C': case 'D': case 'E':
1169 case 'F': case 'G': case 'H': case 'I': case 'J':
1170 case 'K': case 'M': case 'N': case 'O':
1171 case 'P': case 'Q': case 'R': case 'S': case 'T':
1172 case 'U': case 'V': case 'W': case 'X': case 'Y':
1174 case 'a': case 'b': case 'c': case 'd': case 'e':
1175 case 'f': case 'g': case 'h': case 'i': case 'j':
1176 case 'k': case 'l': case 'm': case 'n': case 'o':
1177 case 'p': case 'q': case 'r': case 's': case 't':
1178 case 'u': case 'v': case 'w': case 'x': case 'y':
1183 while (isalnum (c
) || c
== '_' || c
== '$' || c
== '@')
1185 /* Make sure this char really belongs in an identifier. */
1186 if (c
== '@' && ! doing_objc_thang
)
1188 if (c
== '$' && ! dollars_in_ident
)
1191 if (p
>= token_buffer
+ maxtoken
)
1192 p
= extend_token_buffer (p
);
1204 /* Try to recognize a keyword. Uses minimum-perfect hash function */
1207 register struct resword
*ptr
;
1209 if (ptr
= is_reserved_word (token_buffer
, p
- token_buffer
))
1212 yylval
.ttype
= ridpointers
[(int) ptr
->rid
];
1213 value
= (int) ptr
->token
;
1215 /* Only return OBJECTNAME if it is a typedef. */
1216 if (doing_objc_thang
&& value
== OBJECTNAME
)
1218 lastiddecl
= lookup_name(yylval
.ttype
);
1220 if (lastiddecl
== NULL_TREE
1221 || TREE_CODE (lastiddecl
) != TYPE_DECL
)
1225 /* Even if we decided to recognize asm, still perhaps warn. */
1227 && (value
== ASM_KEYWORD
|| value
== TYPEOF
1228 || ptr
->rid
== RID_INLINE
)
1229 && token_buffer
[0] != '_')
1230 pedwarn ("ANSI does not permit the keyword `%s'",
1235 /* If we did not find a keyword, look for an identifier
1238 if (value
== IDENTIFIER
)
1240 if (token_buffer
[0] == '@')
1241 error("invalid identifier `%s'", token_buffer
);
1243 yylval
.ttype
= get_identifier (token_buffer
);
1244 lastiddecl
= lookup_name (yylval
.ttype
);
1246 if (lastiddecl
!= 0 && TREE_CODE (lastiddecl
) == TYPE_DECL
)
1248 /* A user-invisible read-only initialized variable
1249 should be replaced by its value.
1250 We handle only strings since that's the only case used in C. */
1251 else if (lastiddecl
!= 0 && TREE_CODE (lastiddecl
) == VAR_DECL
1252 && DECL_IGNORED_P (lastiddecl
)
1253 && TREE_READONLY (lastiddecl
)
1254 && DECL_INITIAL (lastiddecl
) != 0
1255 && TREE_CODE (DECL_INITIAL (lastiddecl
)) == STRING_CST
)
1257 tree stringval
= DECL_INITIAL (lastiddecl
);
1259 /* Copy the string value so that we won't clobber anything
1260 if we put something in the TREE_CHAIN of this one. */
1261 yylval
.ttype
= build_string (TREE_STRING_LENGTH (stringval
),
1262 TREE_STRING_POINTER (stringval
));
1265 else if (doing_objc_thang
)
1267 tree objc_interface_decl
= is_class_name (yylval
.ttype
);
1269 if (objc_interface_decl
)
1272 yylval
.ttype
= objc_interface_decl
;
1279 case '0': case '1': case '2': case '3': case '4':
1280 case '5': case '6': case '7': case '8': case '9':
1285 int largest_digit
= 0;
1287 /* for multi-precision arithmetic,
1288 we actually store only HOST_BITS_PER_CHAR bits in each part.
1289 The number of parts is chosen so as to be sufficient to hold
1290 the enough bits to fit into the two HOST_WIDE_INTs that contain
1291 the integer value (this is always at least as many bits as are
1292 in a target `long long' value, but may be wider). */
1293 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1294 int parts
[TOTAL_PARTS
];
1297 enum anon1
{ NOT_FLOAT
, AFTER_POINT
, TOO_MANY_POINTS
} floatflag
1300 for (count
= 0; count
< TOTAL_PARTS
; count
++)
1308 *p
++ = (c
= getc (finput
));
1309 if ((c
== 'x') || (c
== 'X'))
1312 *p
++ = (c
= getc (finput
));
1314 /* Leading 0 forces octal unless the 0 is the only digit. */
1315 else if (c
>= '0' && c
<= '9')
1324 /* Read all the digits-and-decimal-points. */
1327 || (isalnum (c
) && c
!= 'l' && c
!= 'L'
1328 && c
!= 'u' && c
!= 'U'
1329 && c
!= 'i' && c
!= 'I' && c
!= 'j' && c
!= 'J'
1330 && (floatflag
== NOT_FLOAT
|| ((c
!= 'f') && (c
!= 'F')))))
1335 error ("floating constant may not be in radix 16");
1336 if (floatflag
== AFTER_POINT
)
1338 error ("malformed floating constant");
1339 floatflag
= TOO_MANY_POINTS
;
1342 floatflag
= AFTER_POINT
;
1345 *p
++ = c
= getc (finput
);
1346 /* Accept '.' as the start of a floating-point number
1347 only when it is followed by a digit.
1348 Otherwise, unread the following non-digit
1349 and use the '.' as a structural token. */
1350 if (p
== token_buffer
+ 2 && !isdigit (c
))
1361 error ("parse error at `..'");
1364 token_buffer
[1] = 0;
1371 /* It is not a decimal point.
1372 It should be a digit (perhaps a hex digit). */
1378 else if (base
<= 10)
1380 if (c
== 'e' || c
== 'E')
1383 floatflag
= AFTER_POINT
;
1384 break; /* start of exponent */
1386 error ("nondigits in number and not hexadecimal");
1397 if (c
>= largest_digit
)
1401 for (count
= 0; count
< TOTAL_PARTS
; count
++)
1403 parts
[count
] *= base
;
1407 += (parts
[count
-1] >> HOST_BITS_PER_CHAR
);
1409 &= (1 << HOST_BITS_PER_CHAR
) - 1;
1415 /* If the extra highest-order part ever gets anything in it,
1416 the number is certainly too big. */
1417 if (parts
[TOTAL_PARTS
- 1] != 0)
1420 if (p
>= token_buffer
+ maxtoken
- 3)
1421 p
= extend_token_buffer (p
);
1422 *p
++ = (c
= getc (finput
));
1427 error ("numeric constant with no digits");
1429 if (largest_digit
>= base
)
1430 error ("numeric constant contains digits beyond the radix");
1432 /* Remove terminating char from the token buffer and delimit the string */
1435 if (floatflag
!= NOT_FLOAT
)
1437 tree type
= double_type_node
;
1438 int garbage_chars
= 0, exceeds_double
= 0;
1440 REAL_VALUE_TYPE value
;
1443 /* Read explicit exponent if any, and put it in tokenbuf. */
1445 if ((c
== 'e') || (c
== 'E'))
1447 if (p
>= token_buffer
+ maxtoken
- 3)
1448 p
= extend_token_buffer (p
);
1451 if ((c
== '+') || (c
== '-'))
1457 error ("floating constant exponent has no digits");
1460 if (p
>= token_buffer
+ maxtoken
- 3)
1461 p
= extend_token_buffer (p
);
1470 /* Convert string to a double, checking for overflow. */
1471 if (setjmp (handler
))
1473 error ("floating constant out of range");
1478 set_float_handler (handler
);
1480 /* The second argument, machine_mode, of REAL_VALUE_ATOF tells the
1481 desired precision of the binary result of decimal-to-binary conversion. */
1483 /* Read the suffixes to choose a data type. */
1487 type
= float_type_node
;
1488 value
= REAL_VALUE_ATOF (token_buffer
, TYPE_MODE (type
));
1489 if (REAL_VALUE_ISINF (value
) && pedantic
)
1490 pedwarn ("floating point number exceeds range of `float'");
1495 type
= long_double_type_node
;
1496 value
= REAL_VALUE_ATOF (token_buffer
, TYPE_MODE (type
));
1497 if (REAL_VALUE_ISINF (value
) && pedantic
)
1499 "floating point number exceeds range of `long double'");
1505 error ("more than one `i' or `j' in numeric constant");
1511 value
= REAL_VALUE_ATOF (token_buffer
, TYPE_MODE (type
));
1512 if (REAL_VALUE_ISINF (value
) && pedantic
)
1513 pedwarn ("floating point number exceeds range of `double'");
1515 set_float_handler (NULL_PTR
);
1518 if (errno
== ERANGE
&& !flag_traditional
&& pedantic
)
1520 /* ERANGE is also reported for underflow,
1521 so test the value to distinguish overflow from that. */
1522 if (REAL_VALUES_LESS (dconst1
, value
)
1523 || REAL_VALUES_LESS (value
, dconstm1
))
1525 pedwarn ("floating point number exceeds range of `double'");
1530 /* Note: garbage_chars is -1 if first char is *not* garbage. */
1531 while (isalnum (c
) || c
== '.' || c
== '_'
1532 || (!flag_traditional
&& (c
== '+' || c
== '-')
1533 && (p
[-1] == 'e' || p
[-1] == 'E')))
1535 if (p
>= token_buffer
+ maxtoken
- 3)
1536 p
= extend_token_buffer (p
);
1541 if (garbage_chars
> 0)
1542 error ("garbage at end of number");
1544 /* Create a node with determined type and value. */
1546 yylval
.ttype
= build_complex (convert (type
, integer_zero_node
),
1547 build_real (type
, value
));
1549 yylval
.ttype
= build_real (type
, value
);
1556 tree traditional_type
, ansi_type
, type
;
1557 HOST_WIDE_INT high
, low
;
1558 int spec_unsigned
= 0;
1560 int spec_long_long
= 0;
1566 if (c
== 'u' || c
== 'U')
1569 error ("two `u's in integer constant");
1572 else if (c
== 'l' || c
== 'L')
1577 error ("three `l's in integer constant");
1579 pedwarn ("ANSI C forbids long long integer constants");
1584 else if (c
== 'i' || c
== 'j' || c
== 'I' || c
== 'J')
1587 error ("more than one `i' or `j' in numeric constant");
1592 if (isalnum (c
) || c
== '.' || c
== '_'
1593 || (!flag_traditional
&& (c
== '+' || c
== '-')
1594 && (p
[-1] == 'e' || p
[-1] == 'E')))
1596 error ("garbage at end of number");
1597 while (isalnum (c
) || c
== '.' || c
== '_'
1598 || (!flag_traditional
&& (c
== '+' || c
== '-')
1599 && (p
[-1] == 'e' || p
[-1] == 'E')))
1601 if (p
>= token_buffer
+ maxtoken
- 3)
1602 p
= extend_token_buffer (p
);
1609 if (p
>= token_buffer
+ maxtoken
- 3)
1610 p
= extend_token_buffer (p
);
1617 /* If the constant is not long long and it won't fit in an
1618 unsigned long, or if the constant is long long and won't fit
1619 in an unsigned long long, then warn that the constant is out
1622 /* ??? This assumes that long long and long integer types are
1623 a multiple of 8 bits. This better than the original code
1624 though which assumed that long was exactly 32 bits and long
1625 long was exactly 64 bits. */
1628 bytes
= TYPE_PRECISION (long_long_integer_type_node
) / 8;
1630 bytes
= TYPE_PRECISION (long_integer_type_node
) / 8;
1633 for (i
= bytes
; i
< TOTAL_PARTS
; i
++)
1637 pedwarn ("integer constant out of range");
1639 /* This is simplified by the fact that our constant
1640 is always positive. */
1644 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
; i
++)
1646 high
|= ((HOST_WIDE_INT
) parts
[i
+ (HOST_BITS_PER_WIDE_INT
1647 / HOST_BITS_PER_CHAR
)]
1648 << (i
* HOST_BITS_PER_CHAR
));
1649 low
|= (HOST_WIDE_INT
) parts
[i
] << (i
* HOST_BITS_PER_CHAR
);
1652 yylval
.ttype
= build_int_2 (low
, high
);
1653 TREE_TYPE (yylval
.ttype
) = long_long_unsigned_type_node
;
1655 /* If warn_traditional, calculate both the ANSI type and the
1656 traditional type, then see if they disagree.
1657 Otherwise, calculate only the type for the dialect in use. */
1658 if (warn_traditional
|| flag_traditional
)
1660 /* Calculate the traditional type. */
1661 /* Traditionally, any constant is signed;
1662 but if unsigned is specified explicitly, obey that.
1663 Use the smallest size with the right number of bits,
1664 except for one special case with decimal constants. */
1665 if (! spec_long
&& base
!= 10
1666 && int_fits_type_p (yylval
.ttype
, unsigned_type_node
))
1667 traditional_type
= (spec_unsigned
? unsigned_type_node
1668 : integer_type_node
);
1669 /* A decimal constant must be long
1670 if it does not fit in type int.
1671 I think this is independent of whether
1672 the constant is signed. */
1673 else if (! spec_long
&& base
== 10
1674 && int_fits_type_p (yylval
.ttype
, integer_type_node
))
1675 traditional_type
= (spec_unsigned
? unsigned_type_node
1676 : integer_type_node
);
1677 else if (! spec_long_long
)
1678 traditional_type
= (spec_unsigned
? long_unsigned_type_node
1679 : long_integer_type_node
);
1681 traditional_type
= (spec_unsigned
1682 ? long_long_unsigned_type_node
1683 : long_long_integer_type_node
);
1685 if (warn_traditional
|| ! flag_traditional
)
1687 /* Calculate the ANSI type. */
1688 if (! spec_long
&& ! spec_unsigned
1689 && int_fits_type_p (yylval
.ttype
, integer_type_node
))
1690 ansi_type
= integer_type_node
;
1691 else if (! spec_long
&& (base
!= 10 || spec_unsigned
)
1692 && int_fits_type_p (yylval
.ttype
, unsigned_type_node
))
1693 ansi_type
= unsigned_type_node
;
1694 else if (! spec_unsigned
&& !spec_long_long
1695 && int_fits_type_p (yylval
.ttype
, long_integer_type_node
))
1696 ansi_type
= long_integer_type_node
;
1697 else if (! spec_long_long
)
1698 ansi_type
= long_unsigned_type_node
;
1699 else if (! spec_unsigned
1700 /* Verify value does not overflow into sign bit. */
1701 && TREE_INT_CST_HIGH (yylval
.ttype
) >= 0
1702 && int_fits_type_p (yylval
.ttype
,
1703 long_long_integer_type_node
))
1704 ansi_type
= long_long_integer_type_node
;
1706 ansi_type
= long_long_unsigned_type_node
;
1709 type
= flag_traditional
? traditional_type
: ansi_type
;
1711 if (warn_traditional
&& traditional_type
!= ansi_type
)
1713 if (TYPE_PRECISION (traditional_type
)
1714 != TYPE_PRECISION (ansi_type
))
1715 warning ("width of integer constant changes with -traditional");
1716 else if (TREE_UNSIGNED (traditional_type
)
1717 != TREE_UNSIGNED (ansi_type
))
1718 warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1720 warning ("width of integer constant may change on other systems with -traditional");
1723 if (!flag_traditional
&& !int_fits_type_p (yylval
.ttype
, type
)
1725 pedwarn ("integer constant out of range");
1727 if (base
== 10 && ! spec_unsigned
&& TREE_UNSIGNED (type
))
1728 warning ("decimal constant is so large that it is unsigned");
1732 if (TYPE_PRECISION (type
)
1733 <= TYPE_PRECISION (integer_type_node
))
1735 = build_complex (integer_zero_node
,
1736 convert (integer_type_node
, yylval
.ttype
));
1738 error ("complex integer constant is too wide for `complex int'");
1740 else if (flag_traditional
&& !int_fits_type_p (yylval
.ttype
, type
))
1741 /* The traditional constant 0x80000000 is signed
1742 but doesn't fit in the range of int.
1743 This will change it to -0x80000000, which does fit. */
1745 TREE_TYPE (yylval
.ttype
) = unsigned_type (type
);
1746 yylval
.ttype
= convert (type
, yylval
.ttype
);
1749 TREE_TYPE (yylval
.ttype
) = type
;
1754 value
= CONSTANT
; break;
1760 register int result
= 0;
1761 register int num_chars
= 0;
1762 unsigned width
= TYPE_PRECISION (char_type_node
);
1767 width
= WCHAR_TYPE_SIZE
;
1768 #ifdef MULTIBYTE_CHARS
1769 max_chars
= MB_CUR_MAX
;
1775 max_chars
= TYPE_PRECISION (integer_type_node
) / width
;
1783 if (c
== '\'' || c
== EOF
)
1789 c
= readescape (&ignore
);
1792 if (width
< HOST_BITS_PER_INT
1793 && (unsigned) c
>= (1 << width
))
1794 pedwarn ("escape sequence out of range for character");
1795 #ifdef MAP_CHARACTER
1797 c
= MAP_CHARACTER (c
);
1803 pedwarn ("ANSI C forbids newline in character constant");
1806 #ifdef MAP_CHARACTER
1808 c
= MAP_CHARACTER (c
);
1812 if (num_chars
> maxtoken
- 4)
1813 extend_token_buffer (token_buffer
);
1815 token_buffer
[num_chars
] = c
;
1817 /* Merge character into result; ignore excess chars. */
1818 if (num_chars
< max_chars
+ 1)
1820 if (width
< HOST_BITS_PER_INT
)
1821 result
= (result
<< width
) | (c
& ((1 << width
) - 1));
1827 token_buffer
[num_chars
+ 1] = '\'';
1828 token_buffer
[num_chars
+ 2] = 0;
1831 error ("malformatted character constant");
1832 else if (num_chars
== 0)
1833 error ("empty character constant");
1834 else if (num_chars
> max_chars
)
1836 num_chars
= max_chars
;
1837 error ("character constant too long");
1839 else if (num_chars
!= 1 && ! flag_traditional
)
1840 warning ("multi-character character constant");
1842 /* If char type is signed, sign-extend the constant. */
1845 int num_bits
= num_chars
* width
;
1846 if (TREE_UNSIGNED (char_type_node
)
1847 || ((result
>> (num_bits
- 1)) & 1) == 0)
1849 = build_int_2 (result
& ((unsigned HOST_WIDE_INT
) ~0
1850 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
1854 = build_int_2 (result
| ~((unsigned HOST_WIDE_INT
) ~0
1855 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
1857 TREE_TYPE (yylval
.ttype
) = integer_type_node
;
1861 #ifdef MULTIBYTE_CHARS
1862 /* Set the initial shift state and convert the next sequence. */
1864 /* In all locales L'\0' is zero and mbtowc will return zero,
1867 || (num_chars
== 1 && token_buffer
[1] != '\0'))
1870 (void) mbtowc (NULL_PTR
, NULL_PTR
, 0);
1871 if (mbtowc (& wc
, token_buffer
+ 1, num_chars
) == num_chars
)
1874 warning ("Ignoring invalid multibyte character");
1877 yylval
.ttype
= build_int_2 (result
, 0);
1878 TREE_TYPE (yylval
.ttype
) = wchar_type_node
;
1889 p
= token_buffer
+ 1;
1891 while (c
!= '"' && c
>= 0)
1893 /* ignore_escape_flag is set for reading the filename in #line. */
1894 if (!ignore_escape_flag
&& c
== '\\')
1897 c
= readescape (&ignore
);
1901 && TYPE_PRECISION (char_type_node
) < HOST_BITS_PER_INT
1902 && c
>= (1 << TYPE_PRECISION (char_type_node
)))
1903 pedwarn ("escape sequence out of range for character");
1908 pedwarn ("ANSI C forbids newline in string constant");
1912 if (p
== token_buffer
+ maxtoken
)
1913 p
= extend_token_buffer (p
);
1921 /* We have read the entire constant.
1922 Construct a STRING_CST for the result. */
1926 /* If this is a L"..." wide-string, convert the multibyte string
1927 to a wide character string. */
1928 char *widep
= (char *) alloca ((p
- token_buffer
) * WCHAR_BYTES
);
1931 #ifdef MULTIBYTE_CHARS
1932 len
= mbstowcs ((wchar_t *) widep
, token_buffer
+ 1, p
- token_buffer
);
1933 if ((unsigned) len
>= (p
- token_buffer
))
1935 warning ("Ignoring invalid multibyte string");
1938 bzero (widep
+ (len
* WCHAR_BYTES
), WCHAR_BYTES
);
1941 union { long l
; char c
[sizeof (long)]; } u
;
1945 /* Determine whether host is little or big endian. */
1947 big_endian
= u
.c
[sizeof (long) - 1];
1948 wp
= widep
+ (big_endian
? WCHAR_BYTES
- 1 : 0);
1950 bzero (widep
, (p
- token_buffer
) * WCHAR_BYTES
);
1951 for (cp
= token_buffer
+ 1; cp
< p
; cp
++)
1952 *wp
= *cp
, wp
+= WCHAR_BYTES
;
1953 len
= p
- token_buffer
- 1;
1956 yylval
.ttype
= build_string ((len
+ 1) * WCHAR_BYTES
, widep
);
1957 TREE_TYPE (yylval
.ttype
) = wchar_array_type_node
;
1962 extern tree
build_objc_string();
1963 /* Return an Objective-C @"..." constant string object. */
1964 yylval
.ttype
= build_objc_string (p
- token_buffer
,
1966 TREE_TYPE (yylval
.ttype
) = char_array_type_node
;
1967 value
= OBJC_STRING
;
1971 yylval
.ttype
= build_string (p
- token_buffer
, token_buffer
+ 1);
1972 TREE_TYPE (yylval
.ttype
) = char_array_type_node
;
2002 yylval
.code
= PLUS_EXPR
; break;
2004 yylval
.code
= MINUS_EXPR
; break;
2006 yylval
.code
= BIT_AND_EXPR
; break;
2008 yylval
.code
= BIT_IOR_EXPR
; break;
2010 yylval
.code
= MULT_EXPR
; break;
2012 yylval
.code
= TRUNC_DIV_EXPR
; break;
2014 yylval
.code
= TRUNC_MOD_EXPR
; break;
2016 yylval
.code
= BIT_XOR_EXPR
; break;
2018 yylval
.code
= LSHIFT_EXPR
; break;
2020 yylval
.code
= RSHIFT_EXPR
; break;
2022 yylval
.code
= LT_EXPR
; break;
2024 yylval
.code
= GT_EXPR
; break;
2027 token_buffer
[1] = c1
= getc (finput
);
2028 token_buffer
[2] = 0;
2035 value
= ARITHCOMPARE
; yylval
.code
= LE_EXPR
; goto done
;
2037 value
= ARITHCOMPARE
; yylval
.code
= GE_EXPR
; goto done
;
2039 value
= EQCOMPARE
; yylval
.code
= NE_EXPR
; goto done
;
2041 value
= EQCOMPARE
; yylval
.code
= EQ_EXPR
; goto done
;
2043 value
= ASSIGN
; goto done
;
2049 value
= PLUSPLUS
; goto done
;
2051 value
= MINUSMINUS
; goto done
;
2053 value
= ANDAND
; goto done
;
2055 value
= OROR
; goto done
;
2063 else if ((c
== '-') && (c1
== '>'))
2064 { value
= POINTSAT
; goto done
; }
2065 ungetc (c1
, finput
);
2066 token_buffer
[1] = 0;
2068 if ((c
== '<') || (c
== '>'))
2069 value
= ARITHCOMPARE
;
2075 /* Don't make yyparse think this is eof. */
2084 /* yylloc.last_line = lineno; */
2089 /* Sets the value of the 'yydebug' variable to VALUE.
2090 This is a function so we don't have to have YYDEBUG defined
2091 in order to build the compiler. */
2100 warning ("YYDEBUG not defined.");