OSDN Git Service

* c-lex.c (MULTIBYTE_CHARS): #undef if cross compiling.
[pf3gnuchains/gcc-fork.git] / gcc / c-lex.c
1 /* Lexical analyzer for C and Objective C.
2    Copyright (C) 1987, 88, 89, 92, 94-96, 1997 Free Software Foundation, Inc.
3
4 This file is part of GNU CC.
5
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)
9 any later version.
10
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.
15
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.  */
20
21 #include "config.h"
22
23 #include <stdio.h>
24 #include <errno.h>
25 #include <setjmp.h>
26
27 #include "rtl.h"
28 #include "tree.h"
29 #include "input.h"
30 #include "c-lex.h"
31 #include "c-tree.h"
32 #include "flags.h"
33 #include "c-parse.h"
34 #include "c-pragma.h"
35
36 #include <ctype.h>
37
38 /* MULTIBYTE_CHARS support only works for native compilers.
39    ??? Ideally what we want is to model widechar support after
40    the current floating point support.  */
41 #ifdef CROSS_COMPILE
42 #undef MULTIBYTE_CHARS
43 #endif
44
45 #ifdef MULTIBYTE_CHARS
46 #include <stdlib.h>
47 #include <locale.h>
48 #endif
49
50 #ifndef errno
51 extern int errno;
52 #endif
53
54 #if USE_CPPLIB
55 #include "cpplib.h"
56 cpp_reader parse_in;
57 cpp_options parse_options;
58 static enum cpp_token cpp_token;
59 #endif
60
61 /* The elements of `ridpointers' are identifier nodes
62    for the reserved type names and storage classes.
63    It is indexed by a RID_... value.  */
64 tree ridpointers[(int) RID_MAX];
65
66 /* Cause the `yydebug' variable to be defined.  */
67 #define YYDEBUG 1
68
69 #if USE_CPPLIB
70 static unsigned char *yy_cur, *yy_lim;
71
72 int
73 yy_get_token ()
74 {
75   for (;;)
76     {
77       parse_in.limit = parse_in.token_buffer;
78       cpp_token = cpp_get_token (&parse_in);
79       if (cpp_token == CPP_EOF)
80         return -1;
81       yy_lim = CPP_PWRITTEN (&parse_in);
82       yy_cur = parse_in.token_buffer;
83       if (yy_cur < yy_lim)
84         return *yy_cur++;
85     }
86 }
87
88 #define GETC() (yy_cur < yy_lim ? *yy_cur++ : yy_get_token ())
89 #define UNGETC(c) ((c), yy_cur--)
90 #else
91 #define GETC() getc (finput)
92 #define UNGETC(c) ungetc (c, finput)
93 #endif
94
95 /* the declaration found for the last IDENTIFIER token read in.
96    yylex must look this up to detect typedefs, which get token type TYPENAME,
97    so it is left around in case the identifier is not a typedef but is
98    used in a context which makes it a reference to a variable.  */
99 tree lastiddecl;
100
101 /* Nonzero enables objc features.  */
102
103 int doing_objc_thang;
104
105 extern tree is_class_name ();
106
107 extern int yydebug;
108
109 /* File used for outputting assembler code.  */
110 extern FILE *asm_out_file;
111
112 #ifndef WCHAR_TYPE_SIZE
113 #ifdef INT_TYPE_SIZE
114 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
115 #else
116 #define WCHAR_TYPE_SIZE BITS_PER_WORD
117 #endif
118 #endif
119
120 /* Number of bytes in a wide character.  */
121 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
122
123 static int maxtoken;            /* Current nominal length of token buffer.  */
124 char *token_buffer;     /* Pointer to token buffer.
125                            Actual allocated length is maxtoken + 2.
126                            This is not static because objc-parse.y uses it.  */
127
128 static int indent_level = 0;        /* Number of { minus number of }. */
129
130 /* Nonzero if end-of-file has been seen on input.  */
131 static int end_of_file;
132
133 #if !USE_CPPLIB
134 /* Buffered-back input character; faster than using ungetc.  */
135 static int nextchar = -1;
136 #endif
137
138 int check_newline ();
139 \f
140 /* Do not insert generated code into the source, instead, include it.
141    This allows us to build gcc automatically even for targets that
142    need to add or modify the reserved keyword lists.  */
143 #include "c-gperf.h"
144 \f
145 /* Return something to represent absolute declarators containing a *.
146    TARGET is the absolute declarator that the * contains.
147    TYPE_QUALS is a list of modifiers such as const or volatile
148    to apply to the pointer type, represented as identifiers.
149
150    We return an INDIRECT_REF whose "contents" are TARGET
151    and whose type is the modifier list.  */
152
153 tree
154 make_pointer_declarator (type_quals, target)
155      tree type_quals, target;
156 {
157   return build1 (INDIRECT_REF, type_quals, target);
158 }
159 \f
160 void
161 forget_protocol_qualifiers ()
162 {
163   int i, n = sizeof wordlist / sizeof (struct resword);
164
165   for (i = 0; i < n; i++)
166     if ((int) wordlist[i].rid >= (int) RID_IN
167         && (int) wordlist[i].rid <= (int) RID_ONEWAY)
168       wordlist[i].name = "";
169 }
170
171 void
172 remember_protocol_qualifiers ()
173 {
174   int i, n = sizeof wordlist / sizeof (struct resword);
175
176   for (i = 0; i < n; i++)
177     if (wordlist[i].rid == RID_IN)
178       wordlist[i].name = "in";
179     else if (wordlist[i].rid == RID_OUT)
180       wordlist[i].name = "out";
181     else if (wordlist[i].rid == RID_INOUT)
182       wordlist[i].name = "inout";
183     else if (wordlist[i].rid == RID_BYCOPY)
184       wordlist[i].name = "bycopy";
185     else if (wordlist[i].rid == RID_ONEWAY)
186       wordlist[i].name = "oneway";   
187 }
188 \f
189 #if USE_CPPLIB
190 void
191 init_parse (filename)
192      char *filename;
193 {
194   init_lex ();
195   yy_cur = "\n";
196   yy_lim = yy_cur+1;
197
198   cpp_reader_init (&parse_in);
199   parse_in.data = &parse_options;
200   cpp_options_init (&parse_options);
201   cpp_handle_options (&parse_in, 0, NULL); /* FIXME */
202   parse_in.show_column = 1;
203   if (! cpp_start_read (&parse_in, filename))
204     abort ();
205 }
206
207 void
208 finish_parse ()
209 {
210   cpp_finish (&parse_in);
211 }
212 #endif
213
214 void
215 init_lex ()
216 {
217   /* Make identifier nodes long enough for the language-specific slots.  */
218   set_identifier_size (sizeof (struct lang_identifier));
219
220   /* Start it at 0, because check_newline is called at the very beginning
221      and will increment it to 1.  */
222   lineno = 0;
223
224 #ifdef MULTIBYTE_CHARS
225   /* Change to the native locale for multibyte conversions.  */
226   setlocale (LC_CTYPE, "");
227 #endif
228
229   maxtoken = 40;
230   token_buffer = (char *) xmalloc (maxtoken + 2);
231
232   ridpointers[(int) RID_INT] = get_identifier ("int");
233   ridpointers[(int) RID_CHAR] = get_identifier ("char");
234   ridpointers[(int) RID_VOID] = get_identifier ("void");
235   ridpointers[(int) RID_FLOAT] = get_identifier ("float");
236   ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
237   ridpointers[(int) RID_SHORT] = get_identifier ("short");
238   ridpointers[(int) RID_LONG] = get_identifier ("long");
239   ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
240   ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
241   ridpointers[(int) RID_INLINE] = get_identifier ("inline");
242   ridpointers[(int) RID_CONST] = get_identifier ("const");
243   ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
244   ridpointers[(int) RID_AUTO] = get_identifier ("auto");
245   ridpointers[(int) RID_STATIC] = get_identifier ("static");
246   ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
247   ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
248   ridpointers[(int) RID_REGISTER] = get_identifier ("register");
249   ridpointers[(int) RID_ITERATOR] = get_identifier ("iterator");
250   ridpointers[(int) RID_COMPLEX] = get_identifier ("complex");
251   ridpointers[(int) RID_ID] = get_identifier ("id");
252   ridpointers[(int) RID_IN] = get_identifier ("in");
253   ridpointers[(int) RID_OUT] = get_identifier ("out");
254   ridpointers[(int) RID_INOUT] = get_identifier ("inout");
255   ridpointers[(int) RID_BYCOPY] = get_identifier ("bycopy");
256   ridpointers[(int) RID_ONEWAY] = get_identifier ("oneway");
257   forget_protocol_qualifiers();
258
259   /* Some options inhibit certain reserved words.
260      Clear those words out of the hash table so they won't be recognized.  */
261 #define UNSET_RESERVED_WORD(STRING) \
262   do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
263        if (s) s->name = ""; } while (0)
264
265   if (! doing_objc_thang)
266     UNSET_RESERVED_WORD ("id");
267
268   if (flag_traditional)
269     {
270       UNSET_RESERVED_WORD ("const");
271       UNSET_RESERVED_WORD ("volatile");
272       UNSET_RESERVED_WORD ("typeof");
273       UNSET_RESERVED_WORD ("signed");
274       UNSET_RESERVED_WORD ("inline");
275       UNSET_RESERVED_WORD ("iterator");
276       UNSET_RESERVED_WORD ("complex");
277     }
278   if (flag_no_asm)
279     {
280       UNSET_RESERVED_WORD ("asm");
281       UNSET_RESERVED_WORD ("typeof");
282       UNSET_RESERVED_WORD ("inline");
283       UNSET_RESERVED_WORD ("iterator");
284       UNSET_RESERVED_WORD ("complex");
285     }
286 }
287
288 void
289 reinit_parse_for_function ()
290 {
291 }
292 \f
293 /* Function used when yydebug is set, to print a token in more detail.  */
294
295 void
296 yyprint (file, yychar, yylval)
297      FILE *file;
298      int yychar;
299      YYSTYPE yylval;
300 {
301   tree t;
302   switch (yychar)
303     {
304     case IDENTIFIER:
305     case TYPENAME:
306     case OBJECTNAME:
307       t = yylval.ttype;
308       if (IDENTIFIER_POINTER (t))
309         fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
310       break;
311
312     case CONSTANT:
313       t = yylval.ttype;
314       if (TREE_CODE (t) == INTEGER_CST)
315         fprintf (file,
316 #if HOST_BITS_PER_WIDE_INT == 64
317 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
318                  " 0x%lx%016lx",
319 #else
320                  " 0x%x%016x",
321 #endif
322 #else
323 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
324                  " 0x%lx%08lx",
325 #else
326                  " 0x%x%08x",
327 #endif
328 #endif
329                  TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
330       break;
331     }
332 }
333
334 \f
335 /* If C is not whitespace, return C.
336    Otherwise skip whitespace and return first nonwhite char read.  */
337
338 static int
339 skip_white_space (c)
340      register int c;
341 {
342   static int newline_warning = 0;
343
344   for (;;)
345     {
346       switch (c)
347         {
348           /* We don't recognize comments here, because
349              cpp output can include / and * consecutively as operators.
350              Also, there's no need, since cpp removes all comments.  */
351
352         case '\n':
353           c = check_newline ();
354           break;
355
356         case ' ':
357         case '\t':
358         case '\f':
359         case '\v':
360         case '\b':
361           c = GETC();
362           break;
363
364         case '\r':
365           /* ANSI C says the effects of a carriage return in a source file
366              are undefined.  */
367           if (pedantic && !newline_warning)
368             {
369               warning ("carriage return in source file");
370               warning ("(we only warn about the first carriage return)");
371               newline_warning = 1;
372             }
373           c = GETC();
374           break;
375
376         case '\\':
377           c = GETC();
378           if (c == '\n')
379             lineno++;
380           else
381             error ("stray '\\' in program");
382           c = GETC();
383           break;
384
385         default:
386           return (c);
387         }
388     }
389 }
390
391 /* Skips all of the white space at the current location in the input file.
392    Must use and reset nextchar if it has the next character.  */
393
394 void
395 position_after_white_space ()
396 {
397   register int c;
398
399 #if !USE_CPPLIB
400   if (nextchar != -1)
401     c = nextchar, nextchar = -1;
402   else
403 #endif
404     c = GETC();
405
406   UNGETC (skip_white_space (c));
407 }
408
409 /* Make the token buffer longer, preserving the data in it.
410    P should point to just beyond the last valid character in the old buffer.
411    The value we return is a pointer to the new buffer
412    at a place corresponding to P.  */
413
414 static char *
415 extend_token_buffer (p)
416      char *p;
417 {
418   int offset = p - token_buffer;
419
420   maxtoken = maxtoken * 2 + 10;
421   token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
422
423   return token_buffer + offset;
424 }
425
426 \f
427 #if !USE_CPPLIB
428 #define GET_DIRECTIVE_LINE() get_directive_line (finput)
429 #else /* USE_CPPLIB */
430 /* Read the rest of a #-directive from input stream FINPUT.
431    In normal use, the directive name and the white space after it
432    have already been read, so they won't be included in the result.
433    We allow for the fact that the directive line may contain
434    a newline embedded within a character or string literal which forms
435    a part of the directive.
436
437    The value is a string in a reusable buffer.  It remains valid
438    only until the next time this function is called.  */
439
440 static char *
441 GET_DIRECTIVE_LINE ()
442 {
443   static char *directive_buffer = NULL;
444   static unsigned buffer_length = 0;
445   register char *p;
446   register char *buffer_limit;
447   register int looking_for = 0;
448   register int char_escaped = 0;
449
450   if (buffer_length == 0)
451     {
452       directive_buffer = (char *)xmalloc (128);
453       buffer_length = 128;
454     }
455
456   buffer_limit = &directive_buffer[buffer_length];
457
458   for (p = directive_buffer; ; )
459     {
460       int c;
461
462       /* Make buffer bigger if it is full.  */
463       if (p >= buffer_limit)
464         {
465           register unsigned bytes_used = (p - directive_buffer);
466
467           buffer_length *= 2;
468           directive_buffer
469             = (char *)xrealloc (directive_buffer, buffer_length);
470           p = &directive_buffer[bytes_used];
471           buffer_limit = &directive_buffer[buffer_length];
472         }
473
474       c = GETC ();
475
476       /* Discard initial whitespace.  */
477       if ((c == ' ' || c == '\t') && p == directive_buffer)
478         continue;
479
480       /* Detect the end of the directive.  */
481       if (c == '\n' && looking_for == 0)
482         {
483           UNGETC (c);
484           c = '\0';
485         }
486
487       *p++ = c;
488
489       if (c == 0)
490         return directive_buffer;
491
492       /* Handle string and character constant syntax.  */
493       if (looking_for)
494         {
495           if (looking_for == c && !char_escaped)
496             looking_for = 0;    /* Found terminator... stop looking.  */
497         }
498       else
499         if (c == '\'' || c == '"')
500           looking_for = c;      /* Don't stop buffering until we see another
501                                    another one of these (or an EOF).  */
502
503       /* Handle backslash.  */
504       char_escaped = (c == '\\' && ! char_escaped);
505     }
506 }
507 #endif /* USE_CPPLIB */
508 \f
509 /* At the beginning of a line, increment the line number
510    and process any #-directive on this line.
511    If the line is a #-directive, read the entire line and return a newline.
512    Otherwise, return the line's first non-whitespace character.  */
513
514 int
515 check_newline ()
516 {
517   register int c;
518   register int token;
519
520   lineno++;
521
522   /* Read first nonwhite char on the line.  */
523
524   c = GETC();
525   while (c == ' ' || c == '\t')
526     c = GETC();
527
528   if (c != '#')
529     {
530       /* If not #, return it so caller will use it.  */
531       return c;
532     }
533
534   /* Read first nonwhite char after the `#'.  */
535
536   c = GETC();
537   while (c == ' ' || c == '\t')
538     c = GETC();
539
540   /* If a letter follows, then if the word here is `line', skip
541      it and ignore it; otherwise, ignore the line, with an error
542      if the word isn't `pragma', `ident', `define', or `undef'.  */
543
544   if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
545     {
546       if (c == 'p')
547         {
548           if (GETC() == 'r'
549               && GETC() == 'a'
550               && GETC() == 'g'
551               && GETC() == 'm'
552               && GETC() == 'a'
553               && ((c = GETC()) == ' ' || c == '\t' || c == '\n'))
554             {
555               while (c == ' ' || c == '\t')
556                 c = GETC ();
557               if (c == '\n')
558                 return c;
559 #ifdef HANDLE_SYSV_PRAGMA
560               UNGETC (c);
561               token = yylex ();
562               if (token != IDENTIFIER)
563                 goto skipline;
564               return handle_sysv_pragma (token);
565 #else /* !HANDLE_SYSV_PRAGMA */
566 #ifdef HANDLE_PRAGMA
567 #if !USE_CPPLIB
568               UNGETC (c);
569               token = yylex ();
570               if (token != IDENTIFIER)
571                 goto skipline;
572               if (HANDLE_PRAGMA (finput, yylval.ttype))
573                 {
574                   c = GETC ();
575                   return c;
576                 }
577 #else
578               ??? do not know what to do ???;
579 #endif /* !USE_CPPLIB */
580 #endif /* HANDLE_PRAGMA */
581 #endif /* !HANDLE_SYSV_PRAGMA */
582               goto skipline;
583             }
584         }
585
586       else if (c == 'd')
587         {
588           if (GETC() == 'e'
589               && GETC() == 'f'
590               && GETC() == 'i'
591               && GETC() == 'n'
592               && GETC() == 'e'
593               && ((c = GETC()) == ' ' || c == '\t' || c == '\n'))
594             {
595               if (c != '\n')
596                 debug_define (lineno, GET_DIRECTIVE_LINE ());
597               goto skipline;
598             }
599         }
600       else if (c == 'u')
601         {
602           if (GETC() == 'n'
603               && GETC() == 'd'
604               && GETC() == 'e'
605               && GETC() == 'f'
606               && ((c = GETC()) == ' ' || c == '\t' || c == '\n'))
607             {
608               if (c != '\n')
609                 debug_undef (lineno, GET_DIRECTIVE_LINE ());
610               goto skipline;
611             }
612         }
613       else if (c == 'l')
614         {
615           if (GETC() == 'i'
616               && GETC() == 'n'
617               && GETC() == 'e'
618               && ((c = GETC()) == ' ' || c == '\t'))
619             goto linenum;
620         }
621       else if (c == 'i')
622         {
623           if (GETC() == 'd'
624               && GETC() == 'e'
625               && GETC() == 'n'
626               && GETC() == 't'
627               && ((c = GETC()) == ' ' || c == '\t'))
628             {
629               /* #ident.  The pedantic warning is now in cccp.c.  */
630
631               /* Here we have just seen `#ident '.
632                  A string constant should follow.  */
633
634               while (c == ' ' || c == '\t')
635                 c = GETC();
636
637               /* If no argument, ignore the line.  */
638               if (c == '\n')
639                 return c;
640
641               UNGETC (c);
642               token = yylex ();
643               if (token != STRING
644                   || TREE_CODE (yylval.ttype) != STRING_CST)
645                 {
646                   error ("invalid #ident");
647                   goto skipline;
648                 }
649
650               if (!flag_no_ident)
651                 {
652 #ifdef ASM_OUTPUT_IDENT
653                   ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
654 #endif
655                 }
656
657               /* Skip the rest of this line.  */
658               goto skipline;
659             }
660         }
661
662       error ("undefined or invalid # directive");
663       goto skipline;
664     }
665
666 linenum:
667   /* Here we have either `#line' or `# <nonletter>'.
668      In either case, it should be a line number; a digit should follow.  */
669
670   while (c == ' ' || c == '\t')
671     c = GETC();
672
673   /* If the # is the only nonwhite char on the line,
674      just ignore it.  Check the new newline.  */
675   if (c == '\n')
676     return c;
677
678   /* Something follows the #; read a token.  */
679
680   UNGETC (c);
681   token = yylex ();
682
683   if (token == CONSTANT
684       && TREE_CODE (yylval.ttype) == INTEGER_CST)
685     {
686       int old_lineno = lineno;
687       int used_up = 0;
688       /* subtract one, because it is the following line that
689          gets the specified number */
690
691       int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
692
693       /* Is this the last nonwhite stuff on the line?  */
694       c = GETC();
695       while (c == ' ' || c == '\t')
696         c = GETC();
697       if (c == '\n')
698         {
699           /* No more: store the line number and check following line.  */
700           lineno = l;
701           return c;
702         }
703       UNGETC (c);
704
705       /* More follows: it must be a string constant (filename).  */
706
707       /* Read the string constant.  */
708       token = yylex ();
709
710       if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
711         {
712           error ("invalid #line");
713           goto skipline;
714         }
715
716       input_filename
717         = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
718       strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
719       lineno = l;
720
721       /* Each change of file name
722          reinitializes whether we are now in a system header.  */
723       in_system_header = 0;
724
725       if (main_input_filename == 0)
726         main_input_filename = input_filename;
727
728       /* Is this the last nonwhite stuff on the line?  */
729       c = GETC();
730       while (c == ' ' || c == '\t')
731         c = GETC();
732       if (c == '\n')
733         {
734           /* Update the name in the top element of input_file_stack.  */
735           if (input_file_stack)
736             input_file_stack->name = input_filename;
737
738           return c;
739         }
740       UNGETC (c);
741
742       token = yylex ();
743       used_up = 0;
744
745       /* `1' after file name means entering new file.
746          `2' after file name means just left a file.  */
747
748       if (token == CONSTANT
749           && TREE_CODE (yylval.ttype) == INTEGER_CST)
750         {
751           if (TREE_INT_CST_LOW (yylval.ttype) == 1)
752             {
753               /* Pushing to a new file.  */
754               struct file_stack *p
755                 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
756               input_file_stack->line = old_lineno;
757               p->next = input_file_stack;
758               p->name = input_filename;
759               p->indent_level = indent_level;
760               input_file_stack = p;
761               input_file_stack_tick++;
762               debug_start_source_file (input_filename);
763               used_up = 1;
764             }
765           else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
766             {
767               /* Popping out of a file.  */
768               if (input_file_stack->next)
769                 {
770                   struct file_stack *p = input_file_stack;
771                   if (indent_level != p->indent_level)
772                     {
773                       warning_with_file_and_line 
774                         (p->name, old_lineno,
775                          "This file contains more `%c's than `%c's.",
776                          indent_level > p->indent_level ? '{' : '}',
777                          indent_level > p->indent_level ? '}' : '{');
778                     }
779                   input_file_stack = p->next;
780                   free (p);
781                   input_file_stack_tick++;
782                   debug_end_source_file (input_file_stack->line);
783                 }
784               else
785                 error ("#-lines for entering and leaving files don't match");
786
787               used_up = 1;
788             }
789         }
790
791       /* Now that we've pushed or popped the input stack,
792          update the name in the top element.  */
793       if (input_file_stack)
794         input_file_stack->name = input_filename;
795
796       /* If we have handled a `1' or a `2',
797          see if there is another number to read.  */
798       if (used_up)
799         {
800           /* Is this the last nonwhite stuff on the line?  */
801           c = GETC();
802           while (c == ' ' || c == '\t')
803             c = GETC();
804           if (c == '\n')
805             return c;
806           UNGETC (c);
807
808           token = yylex ();
809           used_up = 0;
810         }
811
812       /* `3' after file name means this is a system header file.  */
813
814       if (token == CONSTANT
815           && TREE_CODE (yylval.ttype) == INTEGER_CST
816           && TREE_INT_CST_LOW (yylval.ttype) == 3)
817         in_system_header = 1, used_up = 1;
818
819       if (used_up)
820         {
821           /* Is this the last nonwhite stuff on the line?  */
822           c = GETC();
823           while (c == ' ' || c == '\t')
824             c = GETC();
825           if (c == '\n')
826             return c;
827           UNGETC (c);
828         }
829
830       warning ("unrecognized text at end of #line");
831     }
832   else
833     error ("invalid #-line");
834
835   /* skip the rest of this line.  */
836  skipline:
837 #if !USE_CPPLIB
838   if (c != '\n' && c != EOF && nextchar >= 0)
839     c = nextchar, nextchar = -1;
840 #endif
841   while (c != '\n' && c != EOF)
842     c = GETC();
843   return c;
844 }
845 \f
846 #ifdef HANDLE_SYSV_PRAGMA
847
848 /* Handle a #pragma directive.
849    TOKEN is the token we read after `#pragma'.  Processes the entire input
850    line and returns a character for the caller to reread: either \n or EOF.  */
851
852 /* This function has to be in this file, in order to get at
853    the token types.  */
854
855 int
856 handle_sysv_pragma (token)
857      register int token;
858 {
859   register int c;
860
861   for (;;)
862     {
863       switch (token)
864         {
865         case IDENTIFIER:
866         case TYPENAME:
867         case STRING:
868         case CONSTANT:
869           handle_pragma_token (token_buffer, yylval.ttype);
870           break;
871         default:
872           handle_pragma_token (token_buffer, 0);
873         }
874 #if !USE_CPPLIB
875       if (nextchar >= 0)
876         c = nextchar, nextchar = -1;
877       else
878 #endif
879         c = GETC ();
880
881       while (c == ' ' || c == '\t')
882         c = GETC ();
883       if (c == '\n' || c == EOF)
884         {
885           handle_pragma_token (0, 0);
886           return c;
887         }
888       UNGETC (c);
889       token = yylex ();
890     }
891 }
892
893 #endif /* HANDLE_SYSV_PRAGMA */
894 \f
895 #define ENDFILE -1  /* token that represents end-of-file */
896
897 /* Read an escape sequence, returning its equivalent as a character,
898    or store 1 in *ignore_ptr if it is backslash-newline.  */
899
900 static int
901 readescape (ignore_ptr)
902      int *ignore_ptr;
903 {
904   register int c = GETC();
905   register int code;
906   register unsigned count;
907   unsigned firstdig = 0;
908   int nonnull;
909
910   switch (c)
911     {
912     case 'x':
913       if (warn_traditional)
914         warning ("the meaning of `\\x' varies with -traditional");
915
916       if (flag_traditional)
917         return c;
918
919       code = 0;
920       count = 0;
921       nonnull = 0;
922       while (1)
923         {
924           c = GETC();
925           if (!(c >= 'a' && c <= 'f')
926               && !(c >= 'A' && c <= 'F')
927               && !(c >= '0' && c <= '9'))
928             {
929               UNGETC (c);
930               break;
931             }
932           code *= 16;
933           if (c >= 'a' && c <= 'f')
934             code += c - 'a' + 10;
935           if (c >= 'A' && c <= 'F')
936             code += c - 'A' + 10;
937           if (c >= '0' && c <= '9')
938             code += c - '0';
939           if (code != 0 || count != 0)
940             {
941               if (count == 0)
942                 firstdig = code;
943               count++;
944             }
945           nonnull = 1;
946         }
947       if (! nonnull)
948         error ("\\x used with no following hex digits");
949       else if (count == 0)
950         /* Digits are all 0's.  Ok.  */
951         ;
952       else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
953                || (count > 1
954                    && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
955                        <= firstdig)))
956         pedwarn ("hex escape out of range");
957       return code;
958
959     case '0':  case '1':  case '2':  case '3':  case '4':
960     case '5':  case '6':  case '7':
961       code = 0;
962       count = 0;
963       while ((c <= '7') && (c >= '0') && (count++ < 3))
964         {
965           code = (code * 8) + (c - '0');
966           c = GETC();
967         }
968       UNGETC (c);
969       return code;
970
971     case '\\': case '\'': case '"':
972       return c;
973
974     case '\n':
975       lineno++;
976       *ignore_ptr = 1;
977       return 0;
978
979     case 'n':
980       return TARGET_NEWLINE;
981
982     case 't':
983       return TARGET_TAB;
984
985     case 'r':
986       return TARGET_CR;
987
988     case 'f':
989       return TARGET_FF;
990
991     case 'b':
992       return TARGET_BS;
993
994     case 'a':
995       if (warn_traditional)
996         warning ("the meaning of `\\a' varies with -traditional");
997
998       if (flag_traditional)
999         return c;
1000       return TARGET_BELL;
1001
1002     case 'v':
1003 #if 0 /* Vertical tab is present in common usage compilers.  */
1004       if (flag_traditional)
1005         return c;
1006 #endif
1007       return TARGET_VT;
1008
1009     case 'e':
1010     case 'E':
1011       if (pedantic)
1012         pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
1013       return 033;
1014
1015     case '?':
1016       return c;
1017
1018       /* `\(', etc, are used at beginning of line to avoid confusing Emacs.  */
1019     case '(':
1020     case '{':
1021     case '[':
1022       /* `\%' is used to prevent SCCS from getting confused.  */
1023     case '%':
1024       if (pedantic)
1025         pedwarn ("non-ANSI escape sequence `\\%c'", c);
1026       return c;
1027     }
1028   if (c >= 040 && c < 0177)
1029     pedwarn ("unknown escape sequence `\\%c'", c);
1030   else
1031     pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
1032   return c;
1033 }
1034 \f
1035 void
1036 yyerror (string)
1037      char *string;
1038 {
1039   char buf[200];
1040
1041   strcpy (buf, string);
1042
1043   /* We can't print string and character constants well
1044      because the token_buffer contains the result of processing escapes.  */
1045   if (end_of_file)
1046     strcat (buf, " at end of input");
1047   else if (token_buffer[0] == 0)
1048     strcat (buf, " at null character");
1049   else if (token_buffer[0] == '"')
1050     strcat (buf, " before string constant");
1051   else if (token_buffer[0] == '\'')
1052     strcat (buf, " before character constant");
1053   else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
1054     sprintf (buf + strlen (buf), " before character 0%o",
1055              (unsigned char) token_buffer[0]);
1056   else
1057     strcat (buf, " before `%s'");
1058
1059   error (buf, token_buffer);
1060 }
1061
1062 #if 0
1063
1064 struct try_type
1065 {
1066   tree *node_var;
1067   char unsigned_flag;
1068   char long_flag;
1069   char long_long_flag;
1070 };
1071
1072 struct try_type type_sequence[] = 
1073 {
1074   { &integer_type_node, 0, 0, 0},
1075   { &unsigned_type_node, 1, 0, 0},
1076   { &long_integer_type_node, 0, 1, 0},
1077   { &long_unsigned_type_node, 1, 1, 0},
1078   { &long_long_integer_type_node, 0, 1, 1},
1079   { &long_long_unsigned_type_node, 1, 1, 1}
1080 };
1081 #endif /* 0 */
1082 \f
1083 int
1084 yylex ()
1085 {
1086   register int c;
1087   register char *p;
1088   register int value;
1089   int wide_flag = 0;
1090   int objc_flag = 0;
1091
1092 #if !USE_CPPLIB
1093   if (nextchar >= 0)
1094     c = nextchar, nextchar = -1;
1095   else
1096 #endif
1097     c = GETC();
1098
1099   /* Effectively do c = skip_white_space (c)
1100      but do it faster in the usual cases.  */
1101   while (1)
1102     switch (c)
1103       {
1104       case ' ':
1105       case '\t':
1106       case '\f':
1107       case '\v':
1108       case '\b':
1109         c = GETC();
1110         break;
1111
1112       case '\r':
1113         /* Call skip_white_space so we can warn if appropriate.  */
1114
1115       case '\n':
1116       case '/':
1117       case '\\':
1118         c = skip_white_space (c);
1119       default:
1120         goto found_nonwhite;
1121       }
1122  found_nonwhite:
1123
1124   token_buffer[0] = c;
1125   token_buffer[1] = 0;
1126
1127 /*  yylloc.first_line = lineno; */
1128
1129   switch (c)
1130     {
1131     case EOF:
1132       end_of_file = 1;
1133       token_buffer[0] = 0;
1134       value = ENDFILE;
1135       break;
1136
1137     case 'L':
1138       /* Capital L may start a wide-string or wide-character constant.  */
1139       {
1140         register int c = GETC();
1141         if (c == '\'')
1142           {
1143             wide_flag = 1;
1144             goto char_constant;
1145           }
1146         if (c == '"')
1147           {
1148             wide_flag = 1;
1149             goto string_constant;
1150           }
1151         UNGETC (c);
1152       }
1153       goto letter;
1154
1155     case '@':
1156       if (!doing_objc_thang)
1157         {
1158           value = c;
1159           break;
1160         }
1161       else
1162         {
1163           /* '@' may start a constant string object.  */
1164           register int c = GETC ();
1165           if (c == '"')
1166             {
1167               objc_flag = 1;
1168               goto string_constant;
1169             }
1170           UNGETC (c);
1171           /* Fall through to treat '@' as the start of an identifier.  */
1172         }
1173
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 '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':
1179     case 'Z':
1180     case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
1181     case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
1182     case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
1183     case 'p':  case 'q':  case 'r':  case 's':  case 't':
1184     case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
1185     case 'z':
1186     case '_':
1187     case '$':
1188     letter:
1189       p = token_buffer;
1190       while (isalnum (c) || c == '_' || c == '$' || c == '@')
1191         {
1192           /* Make sure this char really belongs in an identifier.  */
1193           if (c == '@' && ! doing_objc_thang)
1194             break;
1195           if (c == '$')
1196             {
1197               if (! dollars_in_ident)
1198                 error ("`$' in identifier");
1199               else if (pedantic)
1200                 pedwarn ("`$' in identifier");
1201             }
1202
1203           if (p >= token_buffer + maxtoken)
1204             p = extend_token_buffer (p);
1205
1206           *p++ = c;
1207           c = GETC();
1208         }
1209
1210       *p = 0;
1211 #if USE_CPPLIB
1212       UNGETC (c);
1213 #else
1214       nextchar = c;
1215 #endif
1216
1217       value = IDENTIFIER;
1218       yylval.itype = 0;
1219
1220       /* Try to recognize a keyword.  Uses minimum-perfect hash function */
1221
1222       {
1223         register struct resword *ptr;
1224
1225         if (ptr = is_reserved_word (token_buffer, p - token_buffer))
1226           {
1227             if (ptr->rid)
1228               yylval.ttype = ridpointers[(int) ptr->rid];
1229             value = (int) ptr->token;
1230
1231             /* Only return OBJECTNAME if it is a typedef.  */
1232             if (doing_objc_thang && value == OBJECTNAME)
1233               {
1234                 lastiddecl = lookup_name(yylval.ttype);
1235
1236                 if (lastiddecl == NULL_TREE
1237                     || TREE_CODE (lastiddecl) != TYPE_DECL)
1238                   value = IDENTIFIER;
1239               }
1240
1241             /* Even if we decided to recognize asm, still perhaps warn.  */
1242             if (pedantic
1243                 && (value == ASM_KEYWORD || value == TYPEOF
1244                     || ptr->rid == RID_INLINE)
1245                 && token_buffer[0] != '_')
1246               pedwarn ("ANSI does not permit the keyword `%s'",
1247                        token_buffer);
1248           }
1249       }
1250
1251       /* If we did not find a keyword, look for an identifier
1252          (or a typename).  */
1253
1254       if (value == IDENTIFIER)
1255         {
1256           if (token_buffer[0] == '@')
1257             error("invalid identifier `%s'", token_buffer);
1258
1259           yylval.ttype = get_identifier (token_buffer);
1260           lastiddecl = lookup_name (yylval.ttype);
1261
1262           if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1263             value = TYPENAME;
1264           /* A user-invisible read-only initialized variable
1265              should be replaced by its value.
1266              We handle only strings since that's the only case used in C.  */
1267           else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
1268                    && DECL_IGNORED_P (lastiddecl)
1269                    && TREE_READONLY (lastiddecl)
1270                    && DECL_INITIAL (lastiddecl) != 0
1271                    && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
1272             {
1273               tree stringval = DECL_INITIAL (lastiddecl);
1274               
1275               /* Copy the string value so that we won't clobber anything
1276                  if we put something in the TREE_CHAIN of this one.  */
1277               yylval.ttype = build_string (TREE_STRING_LENGTH (stringval),
1278                                            TREE_STRING_POINTER (stringval));
1279               value = STRING;
1280             }
1281           else if (doing_objc_thang)
1282             {
1283               tree objc_interface_decl = is_class_name (yylval.ttype);
1284
1285               if (objc_interface_decl)
1286                 {
1287                   value = CLASSNAME;
1288                   yylval.ttype = objc_interface_decl;
1289                 }
1290             }
1291         }
1292
1293       break;
1294
1295     case '0':  case '1':
1296       {
1297         int next_c;
1298         /* Check first for common special case:  single-digit 0 or 1.  */
1299
1300         next_c = GETC ();
1301         UNGETC (next_c);        /* Always undo this lookahead.  */
1302         if (!isalnum (next_c) && next_c != '.')
1303           {
1304             token_buffer[0] = (char)c,  token_buffer[1] = '\0';
1305             yylval.ttype = (c == '0') ? integer_zero_node : integer_one_node;
1306             value = CONSTANT;
1307             break;
1308           }
1309         /*FALLTHRU*/
1310       }
1311     case '2':  case '3':  case '4':
1312     case '5':  case '6':  case '7':  case '8':  case '9':
1313     case '.':
1314       {
1315         int base = 10;
1316         int count = 0;
1317         int largest_digit = 0;
1318         int numdigits = 0;
1319         /* for multi-precision arithmetic,
1320            we actually store only HOST_BITS_PER_CHAR bits in each part.
1321            The number of parts is chosen so as to be sufficient to hold
1322            the enough bits to fit into the two HOST_WIDE_INTs that contain
1323            the integer value (this is always at least as many bits as are
1324            in a target `long long' value, but may be wider).  */
1325 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1326         int parts[TOTAL_PARTS];
1327         int overflow = 0;
1328
1329         enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
1330           = NOT_FLOAT;
1331
1332         for (count = 0; count < TOTAL_PARTS; count++)
1333           parts[count] = 0;
1334
1335         p = token_buffer;
1336         *p++ = c;
1337
1338         if (c == '0')
1339           {
1340             *p++ = (c = GETC());
1341             if ((c == 'x') || (c == 'X'))
1342               {
1343                 base = 16;
1344                 *p++ = (c = GETC());
1345               }
1346             /* Leading 0 forces octal unless the 0 is the only digit.  */
1347             else if (c >= '0' && c <= '9')
1348               {
1349                 base = 8;
1350                 numdigits++;
1351               }
1352             else
1353               numdigits++;
1354           }
1355
1356         /* Read all the digits-and-decimal-points.  */
1357
1358         while (c == '.'
1359                || (isalnum (c) && c != 'l' && c != 'L'
1360                    && c != 'u' && c != 'U'
1361                    && c != 'i' && c != 'I' && c != 'j' && c != 'J'
1362                    && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
1363           {
1364             if (c == '.')
1365               {
1366                 if (base == 16)
1367                   error ("floating constant may not be in radix 16");
1368                 if (floatflag == TOO_MANY_POINTS)
1369                   /* We have already emitted an error.  Don't need another.  */
1370                   ;
1371                 else if (floatflag == AFTER_POINT)
1372                   {
1373                     error ("malformed floating constant");
1374                     floatflag = TOO_MANY_POINTS;
1375                     /* Avoid another error from atof by forcing all characters
1376                        from here on to be ignored.  */
1377                     p[-1] = '\0';
1378                   }
1379                 else
1380                   floatflag = AFTER_POINT;
1381
1382                 base = 10;
1383                 *p++ = c = GETC();
1384                 /* Accept '.' as the start of a floating-point number
1385                    only when it is followed by a digit.
1386                    Otherwise, unread the following non-digit
1387                    and use the '.' as a structural token.  */
1388                 if (p == token_buffer + 2 && !isdigit (c))
1389                   {
1390                     if (c == '.')
1391                       {
1392                         c = GETC();
1393                         if (c == '.')
1394                           {
1395                             *p++ = c;
1396                             *p = 0;
1397                             return ELLIPSIS;
1398                           }
1399                         error ("parse error at `..'");
1400                       }
1401                     UNGETC (c);
1402                     token_buffer[1] = 0;
1403                     value = '.';
1404                     goto done;
1405                   }
1406               }
1407             else
1408               {
1409                 /* It is not a decimal point.
1410                    It should be a digit (perhaps a hex digit).  */
1411
1412                 if (isdigit (c))
1413                   {
1414                     c = c - '0';
1415                   }
1416                 else if (base <= 10)
1417                   {
1418                     if (c == 'e' || c == 'E')
1419                       {
1420                         base = 10;
1421                         floatflag = AFTER_POINT;
1422                         break;   /* start of exponent */
1423                       }
1424                     error ("nondigits in number and not hexadecimal");
1425                     c = 0;
1426                   }
1427                 else if (c >= 'a')
1428                   {
1429                     c = c - 'a' + 10;
1430                   }
1431                 else
1432                   {
1433                     c = c - 'A' + 10;
1434                   }
1435                 if (c >= largest_digit)
1436                   largest_digit = c;
1437                 numdigits++;
1438
1439                 for (count = 0; count < TOTAL_PARTS; count++)
1440                   {
1441                     parts[count] *= base;
1442                     if (count)
1443                       {
1444                         parts[count]
1445                           += (parts[count-1] >> HOST_BITS_PER_CHAR);
1446                         parts[count-1]
1447                           &= (1 << HOST_BITS_PER_CHAR) - 1;
1448                       }
1449                     else
1450                       parts[0] += c;
1451                   }
1452
1453                 /* If the extra highest-order part ever gets anything in it,
1454                    the number is certainly too big.  */
1455                 if (parts[TOTAL_PARTS - 1] != 0)
1456                   overflow = 1;
1457
1458                 if (p >= token_buffer + maxtoken - 3)
1459                   p = extend_token_buffer (p);
1460                 *p++ = (c = GETC());
1461               }
1462           }
1463
1464         if (numdigits == 0)
1465           error ("numeric constant with no digits");
1466
1467         if (largest_digit >= base)
1468           error ("numeric constant contains digits beyond the radix");
1469
1470         /* Remove terminating char from the token buffer and delimit the string */
1471         *--p = 0;
1472
1473         if (floatflag != NOT_FLOAT)
1474           {
1475             tree type = double_type_node;
1476             int exceeds_double = 0;
1477             int imag = 0;
1478             REAL_VALUE_TYPE value;
1479             jmp_buf handler;
1480
1481             /* Read explicit exponent if any, and put it in tokenbuf.  */
1482
1483             if ((c == 'e') || (c == 'E'))
1484               {
1485                 if (p >= token_buffer + maxtoken - 3)
1486                   p = extend_token_buffer (p);
1487                 *p++ = c;
1488                 c = GETC();
1489                 if ((c == '+') || (c == '-'))
1490                   {
1491                     *p++ = c;
1492                     c = GETC();
1493                   }
1494                 if (! isdigit (c))
1495                   error ("floating constant exponent has no digits");
1496                 while (isdigit (c))
1497                   {
1498                     if (p >= token_buffer + maxtoken - 3)
1499                       p = extend_token_buffer (p);
1500                     *p++ = c;
1501                     c = GETC();
1502                   }
1503               }
1504
1505             *p = 0;
1506             errno = 0;
1507
1508             /* Convert string to a double, checking for overflow.  */
1509             if (setjmp (handler))
1510               {
1511                 error ("floating constant out of range");
1512                 value = dconst0;
1513               }
1514             else
1515               {
1516                 int fflag = 0, lflag = 0;
1517                 /* Copy token_buffer now, while it has just the number
1518                    and not the suffixes; once we add `f' or `i',
1519                    REAL_VALUE_ATOF may not work any more.  */
1520                 char *copy = (char *) alloca (p - token_buffer + 1);
1521                 bcopy (token_buffer, copy, p - token_buffer + 1);
1522
1523                 set_float_handler (handler);
1524
1525                 while (1)
1526                   {
1527                     int lose = 0;
1528
1529                     /* Read the suffixes to choose a data type.  */
1530                     switch (c)
1531                       {
1532                       case 'f': case 'F':
1533                         if (fflag)
1534                           error ("more than one `f' in numeric constant");
1535                         fflag = 1;
1536                         break;
1537
1538                       case 'l': case 'L':
1539                         if (lflag)
1540                           error ("more than one `l' in numeric constant");
1541                         lflag = 1;
1542                         break;
1543
1544                       case 'i': case 'I':
1545                         if (imag)
1546                           error ("more than one `i' or `j' in numeric constant");
1547                         else if (pedantic)
1548                           pedwarn ("ANSI C forbids imaginary numeric constants");
1549                         imag = 1;
1550                         break;
1551
1552                       default:
1553                         lose = 1;
1554                       }
1555
1556                     if (lose)
1557                       break;
1558
1559                     if (p >= token_buffer + maxtoken - 3)
1560                       p = extend_token_buffer (p);
1561                     *p++ = c;
1562                     *p = 0;
1563                     c = GETC();
1564                   }
1565
1566                 /* The second argument, machine_mode, of REAL_VALUE_ATOF
1567                    tells the desired precision of the binary result
1568                    of decimal-to-binary conversion.  */
1569
1570                 if (fflag)
1571                   {
1572                     if (lflag)
1573                       error ("both `f' and `l' in floating constant");
1574
1575                     type = float_type_node;
1576                     value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
1577                     /* A diagnostic is required here by some ANSI C testsuites.
1578                        This is not pedwarn, become some people don't want
1579                        an error for this.  */
1580                     if (REAL_VALUE_ISINF (value) && pedantic)
1581                       warning ("floating point number exceeds range of `float'");
1582                   }
1583                 else if (lflag)
1584                   {
1585                     type = long_double_type_node;
1586                     value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
1587                     if (REAL_VALUE_ISINF (value) && pedantic)
1588                       warning ("floating point number exceeds range of `long double'");
1589                   }
1590                 else
1591                   {
1592                     value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
1593                     if (REAL_VALUE_ISINF (value) && pedantic)
1594                       warning ("floating point number exceeds range of `double'");
1595                   }
1596
1597                 set_float_handler (NULL_PTR);
1598             }
1599 #ifdef ERANGE
1600             if (errno == ERANGE && !flag_traditional && pedantic)
1601               {
1602                 /* ERANGE is also reported for underflow,
1603                    so test the value to distinguish overflow from that.  */
1604                 if (REAL_VALUES_LESS (dconst1, value)
1605                     || REAL_VALUES_LESS (value, dconstm1))
1606                   {
1607                     warning ("floating point number exceeds range of `double'");
1608                     exceeds_double = 1;
1609                   }
1610               }
1611 #endif
1612
1613             /* If the result is not a number, assume it must have been
1614                due to some error message above, so silently convert
1615                it to a zero.  */
1616             if (REAL_VALUE_ISNAN (value))
1617               value = dconst0;
1618
1619             /* Create a node with determined type and value.  */
1620             if (imag)
1621               yylval.ttype = build_complex (NULL_TREE,
1622                                             convert (type, integer_zero_node),
1623                                             build_real (type, value));
1624             else
1625               yylval.ttype = build_real (type, value);
1626           }
1627         else
1628           {
1629             tree traditional_type, ansi_type, type;
1630             HOST_WIDE_INT high, low;
1631             int spec_unsigned = 0;
1632             int spec_long = 0;
1633             int spec_long_long = 0;
1634             int spec_imag = 0;
1635             int bytes, warn, i;
1636
1637             while (1)
1638               {
1639                 if (c == 'u' || c == 'U')
1640                   {
1641                     if (spec_unsigned)
1642                       error ("two `u's in integer constant");
1643                     spec_unsigned = 1;
1644                   }
1645                 else if (c == 'l' || c == 'L')
1646                   {
1647                     if (spec_long)
1648                       {
1649                         if (spec_long_long)
1650                           error ("three `l's in integer constant");
1651                         else if (pedantic)
1652                           pedwarn ("ANSI C forbids long long integer constants");
1653                         spec_long_long = 1;
1654                       }
1655                     spec_long = 1;
1656                   }
1657                 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
1658                   {
1659                     if (spec_imag)
1660                       error ("more than one `i' or `j' in numeric constant");
1661                     else if (pedantic)
1662                       pedwarn ("ANSI C forbids imaginary numeric constants");
1663                     spec_imag = 1;
1664                   }
1665                 else
1666                   break;
1667                 if (p >= token_buffer + maxtoken - 3)
1668                   p = extend_token_buffer (p);
1669                 *p++ = c;
1670                 c = GETC();
1671               }
1672
1673             /* If the constant is not long long and it won't fit in an
1674                unsigned long, or if the constant is long long and won't fit
1675                in an unsigned long long, then warn that the constant is out
1676                of range.  */
1677
1678             /* ??? This assumes that long long and long integer types are
1679                a multiple of 8 bits.  This better than the original code
1680                though which assumed that long was exactly 32 bits and long
1681                long was exactly 64 bits.  */
1682
1683             if (spec_long_long)
1684               bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1685             else
1686               bytes = TYPE_PRECISION (long_integer_type_node) / 8;
1687
1688             warn = overflow;
1689             for (i = bytes; i < TOTAL_PARTS; i++)
1690               if (parts[i])
1691                 warn = 1;
1692             if (warn)
1693               pedwarn ("integer constant out of range");
1694
1695             /* This is simplified by the fact that our constant
1696                is always positive.  */
1697
1698             high = low = 0;
1699
1700             for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1701               {
1702                 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1703                                                     / HOST_BITS_PER_CHAR)]
1704                          << (i * HOST_BITS_PER_CHAR));
1705                 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1706               }
1707             
1708             yylval.ttype = build_int_2 (low, high);
1709             TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1710
1711             /* If warn_traditional, calculate both the ANSI type and the
1712                traditional type, then see if they disagree.
1713                Otherwise, calculate only the type for the dialect in use.  */
1714             if (warn_traditional || flag_traditional)
1715               {
1716                 /* Calculate the traditional type.  */
1717                 /* Traditionally, any constant is signed;
1718                    but if unsigned is specified explicitly, obey that.
1719                    Use the smallest size with the right number of bits,
1720                    except for one special case with decimal constants.  */
1721                 if (! spec_long && base != 10
1722                     && int_fits_type_p (yylval.ttype, unsigned_type_node))
1723                   traditional_type = (spec_unsigned ? unsigned_type_node
1724                                       : integer_type_node);
1725                 /* A decimal constant must be long
1726                    if it does not fit in type int.
1727                    I think this is independent of whether
1728                    the constant is signed.  */
1729                 else if (! spec_long && base == 10
1730                          && int_fits_type_p (yylval.ttype, integer_type_node))
1731                   traditional_type = (spec_unsigned ? unsigned_type_node
1732                                       : integer_type_node);
1733                 else if (! spec_long_long)
1734                   traditional_type = (spec_unsigned ? long_unsigned_type_node
1735                                       : long_integer_type_node);
1736                 else
1737                   traditional_type = (spec_unsigned
1738                                       ? long_long_unsigned_type_node
1739                                       : long_long_integer_type_node);
1740               }
1741             if (warn_traditional || ! flag_traditional)
1742               {
1743                 /* Calculate the ANSI type.  */
1744                 if (! spec_long && ! spec_unsigned
1745                     && int_fits_type_p (yylval.ttype, integer_type_node))
1746                   ansi_type = integer_type_node;
1747                 else if (! spec_long && (base != 10 || spec_unsigned)
1748                          && int_fits_type_p (yylval.ttype, unsigned_type_node))
1749                   ansi_type = unsigned_type_node;
1750                 else if (! spec_unsigned && !spec_long_long
1751                          && int_fits_type_p (yylval.ttype, long_integer_type_node))
1752                   ansi_type = long_integer_type_node;
1753                 else if (! spec_long_long)
1754                   ansi_type = long_unsigned_type_node;
1755                 else if (! spec_unsigned
1756                          && int_fits_type_p (yylval.ttype,
1757                                              long_long_integer_type_node))
1758                   ansi_type = long_long_integer_type_node;
1759                 else
1760                   ansi_type = long_long_unsigned_type_node;
1761               }
1762
1763             type = flag_traditional ? traditional_type : ansi_type;
1764
1765             if (warn_traditional && traditional_type != ansi_type)
1766               {
1767                 if (TYPE_PRECISION (traditional_type)
1768                     != TYPE_PRECISION (ansi_type))
1769                   warning ("width of integer constant changes with -traditional");
1770                 else if (TREE_UNSIGNED (traditional_type)
1771                          != TREE_UNSIGNED (ansi_type))
1772                   warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1773                 else
1774                   warning ("width of integer constant may change on other systems with -traditional");
1775               }
1776
1777             if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
1778                 && !warn)
1779               pedwarn ("integer constant out of range");
1780
1781             if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1782               warning ("decimal constant is so large that it is unsigned");
1783
1784             if (spec_imag)
1785               {
1786                 if (TYPE_PRECISION (type)
1787                     <= TYPE_PRECISION (integer_type_node))
1788                   yylval.ttype
1789                     = build_complex (NULL_TREE, integer_zero_node,
1790                                      convert (integer_type_node,
1791                                               yylval.ttype));
1792                 else
1793                   error ("complex integer constant is too wide for `complex int'");
1794               }
1795             else if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1796               /* The traditional constant 0x80000000 is signed
1797                  but doesn't fit in the range of int.
1798                  This will change it to -0x80000000, which does fit.  */
1799               {
1800                 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1801                 yylval.ttype = convert (type, yylval.ttype);
1802                 TREE_OVERFLOW (yylval.ttype)
1803                   = TREE_CONSTANT_OVERFLOW (yylval.ttype) = 0;
1804               }
1805             else
1806               TREE_TYPE (yylval.ttype) = type;
1807           }
1808
1809         UNGETC (c);
1810         *p = 0;
1811
1812         if (isalnum (c) || c == '.' || c == '_' || c == '$'
1813             || (!flag_traditional && (c == '-' || c == '+')
1814                 && (p[-1] == 'e' || p[-1] == 'E')))
1815           error ("missing white space after number `%s'", token_buffer);
1816
1817         value = CONSTANT; break;
1818       }
1819
1820     case '\'':
1821     char_constant:
1822       {
1823         register int result = 0;
1824         register int num_chars = 0;
1825         unsigned width = TYPE_PRECISION (char_type_node);
1826         int max_chars;
1827
1828         if (wide_flag)
1829           {
1830             width = WCHAR_TYPE_SIZE;
1831 #ifdef MULTIBYTE_CHARS
1832             max_chars = MB_CUR_MAX;
1833 #else
1834             max_chars = 1;
1835 #endif
1836           }
1837         else
1838           max_chars = TYPE_PRECISION (integer_type_node) / width;
1839
1840         while (1)
1841           {
1842           tryagain:
1843
1844             c = GETC();
1845
1846             if (c == '\'' || c == EOF)
1847               break;
1848
1849             if (c == '\\')
1850               {
1851                 int ignore = 0;
1852                 c = readescape (&ignore);
1853                 if (ignore)
1854                   goto tryagain;
1855                 if (width < HOST_BITS_PER_INT
1856                     && (unsigned) c >= (1 << width))
1857                   pedwarn ("escape sequence out of range for character");
1858 #ifdef MAP_CHARACTER
1859                 if (isprint (c))
1860                   c = MAP_CHARACTER (c);
1861 #endif
1862               }
1863             else if (c == '\n')
1864               {
1865                 if (pedantic)
1866                   pedwarn ("ANSI C forbids newline in character constant");
1867                 lineno++;
1868               }
1869 #ifdef MAP_CHARACTER
1870             else
1871               c = MAP_CHARACTER (c);
1872 #endif
1873
1874             num_chars++;
1875             if (num_chars > maxtoken - 4)
1876               extend_token_buffer (token_buffer);
1877
1878             token_buffer[num_chars] = c;
1879
1880             /* Merge character into result; ignore excess chars.  */
1881             if (num_chars < max_chars + 1)
1882               {
1883                 if (width < HOST_BITS_PER_INT)
1884                   result = (result << width) | (c & ((1 << width) - 1));
1885                 else
1886                   result = c;
1887               }
1888           }
1889
1890         token_buffer[num_chars + 1] = '\'';
1891         token_buffer[num_chars + 2] = 0;
1892
1893         if (c != '\'')
1894           error ("malformatted character constant");
1895         else if (num_chars == 0)
1896           error ("empty character constant");
1897         else if (num_chars > max_chars)
1898           {
1899             num_chars = max_chars;
1900             error ("character constant too long");
1901           }
1902         else if (num_chars != 1 && ! flag_traditional)
1903           warning ("multi-character character constant");
1904
1905         /* If char type is signed, sign-extend the constant.  */
1906         if (! wide_flag)
1907           {
1908             int num_bits = num_chars * width;
1909             if (num_bits == 0)
1910               /* We already got an error; avoid invalid shift.  */
1911               yylval.ttype = build_int_2 (0, 0);
1912             else if (TREE_UNSIGNED (char_type_node)
1913                      || ((result >> (num_bits - 1)) & 1) == 0)
1914               yylval.ttype
1915                 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
1916                                          >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1917                                0);
1918             else
1919               yylval.ttype
1920                 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
1921                                           >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1922                                -1);
1923             TREE_TYPE (yylval.ttype) = integer_type_node;
1924           }
1925         else
1926           {
1927 #ifdef MULTIBYTE_CHARS
1928             /* Set the initial shift state and convert the next sequence.  */
1929             result = 0;
1930             /* In all locales L'\0' is zero and mbtowc will return zero,
1931                so don't use it.  */
1932             if (num_chars > 1
1933                 || (num_chars == 1 && token_buffer[1] != '\0'))
1934               {
1935                 wchar_t wc;
1936                 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1937                 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1938                   result = wc;
1939                 else
1940                   warning ("Ignoring invalid multibyte character");
1941               }
1942 #endif
1943             yylval.ttype = build_int_2 (result, 0);
1944             TREE_TYPE (yylval.ttype) = wchar_type_node;
1945           }
1946
1947         value = CONSTANT;
1948         break;
1949       }
1950
1951     case '"':
1952     string_constant:
1953       {
1954         c = GETC();
1955         p = token_buffer + 1;
1956
1957         while (c != '"' && c >= 0)
1958           {
1959             if (c == '\\')
1960               {
1961                 int ignore = 0;
1962                 c = readescape (&ignore);
1963                 if (ignore)
1964                   goto skipnewline;
1965                 if (!wide_flag
1966                     && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
1967                     && c >= (1 << TYPE_PRECISION (char_type_node)))
1968                   pedwarn ("escape sequence out of range for character");
1969               }
1970             else if (c == '\n')
1971               {
1972                 if (pedantic)
1973                   pedwarn ("ANSI C forbids newline in string constant");
1974                 lineno++;
1975               }
1976
1977             if (p == token_buffer + maxtoken)
1978               p = extend_token_buffer (p);
1979             *p++ = c;
1980
1981           skipnewline:
1982             c = GETC();
1983           }
1984         *p = 0;
1985
1986         if (c < 0)
1987           error ("Unterminated string constant");
1988
1989         /* We have read the entire constant.
1990            Construct a STRING_CST for the result.  */
1991
1992         if (wide_flag)
1993           {
1994             /* If this is a L"..." wide-string, convert the multibyte string
1995                to a wide character string.  */
1996             char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
1997             int len;
1998
1999 #ifdef MULTIBYTE_CHARS
2000             len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
2001             if (len < 0 || len >= (p - token_buffer))
2002               {
2003                 warning ("Ignoring invalid multibyte string");
2004                 len = 0;
2005               }
2006             bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
2007 #else
2008             {
2009               char *wp, *cp;
2010
2011               wp = widep + (BYTES_BIG_ENDIAN ? WCHAR_BYTES - 1 : 0);
2012               bzero (widep, (p - token_buffer) * WCHAR_BYTES);
2013               for (cp = token_buffer + 1; cp < p; cp++)
2014                 *wp = *cp, wp += WCHAR_BYTES;
2015               len = p - token_buffer - 1;
2016             }
2017 #endif
2018             yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
2019             TREE_TYPE (yylval.ttype) = wchar_array_type_node;
2020             value = STRING;
2021           }
2022         else if (objc_flag)
2023           {
2024             extern tree build_objc_string();
2025             /* Return an Objective-C @"..." constant string object.  */
2026             yylval.ttype = build_objc_string (p - token_buffer,
2027                                               token_buffer + 1);
2028             TREE_TYPE (yylval.ttype) = char_array_type_node;
2029             value = OBJC_STRING;
2030           }
2031         else
2032           {
2033             yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
2034             TREE_TYPE (yylval.ttype) = char_array_type_node;
2035             value = STRING;
2036           }
2037
2038         *p++ = '"';
2039         *p = 0;
2040
2041         break;
2042       }
2043
2044     case '+':
2045     case '-':
2046     case '&':
2047     case '|':
2048     case ':':
2049     case '<':
2050     case '>':
2051     case '*':
2052     case '/':
2053     case '%':
2054     case '^':
2055     case '!':
2056     case '=':
2057       {
2058         register int c1;
2059
2060       combine:
2061
2062         switch (c)
2063           {
2064           case '+':
2065             yylval.code = PLUS_EXPR; break;
2066           case '-':
2067             yylval.code = MINUS_EXPR; break;
2068           case '&':
2069             yylval.code = BIT_AND_EXPR; break;
2070           case '|':
2071             yylval.code = BIT_IOR_EXPR; break;
2072           case '*':
2073             yylval.code = MULT_EXPR; break;
2074           case '/':
2075             yylval.code = TRUNC_DIV_EXPR; break;
2076           case '%':
2077             yylval.code = TRUNC_MOD_EXPR; break;
2078           case '^':
2079             yylval.code = BIT_XOR_EXPR; break;
2080           case LSHIFT:
2081             yylval.code = LSHIFT_EXPR; break;
2082           case RSHIFT:
2083             yylval.code = RSHIFT_EXPR; break;
2084           case '<':
2085             yylval.code = LT_EXPR; break;
2086           case '>':
2087             yylval.code = GT_EXPR; break;
2088           }
2089
2090         token_buffer[1] = c1 = GETC();
2091         token_buffer[2] = 0;
2092
2093         if (c1 == '=')
2094           {
2095             switch (c)
2096               {
2097               case '<':
2098                 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
2099               case '>':
2100                 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
2101               case '!':
2102                 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
2103               case '=':
2104                 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
2105               }
2106             value = ASSIGN; goto done;
2107           }
2108         else if (c == c1)
2109           switch (c)
2110             {
2111             case '+':
2112               value = PLUSPLUS; goto done;
2113             case '-':
2114               value = MINUSMINUS; goto done;
2115             case '&':
2116               value = ANDAND; goto done;
2117             case '|':
2118               value = OROR; goto done;
2119             case '<':
2120               c = LSHIFT;
2121               goto combine;
2122             case '>':
2123               c = RSHIFT;
2124               goto combine;
2125             }
2126         else
2127           switch (c)
2128             {
2129             case '-':
2130               if (c1 == '>')
2131                 { value = POINTSAT; goto done; }
2132               break;
2133             case ':':
2134               if (c1 == '>')
2135                 { value = ']'; goto done; }
2136               break;
2137             case '<':
2138               if (c1 == '%')
2139                 { value = '{'; indent_level++; goto done; }
2140               if (c1 == ':')
2141                 { value = '['; goto done; }
2142               break;
2143             case '%':
2144               if (c1 == '>')
2145                 { value = '}'; indent_level--; goto done; }
2146               break;
2147             }
2148         UNGETC (c1);
2149         token_buffer[1] = 0;
2150
2151         if ((c == '<') || (c == '>'))
2152           value = ARITHCOMPARE;
2153         else value = c;
2154         goto done;
2155       }
2156
2157     case 0:
2158       /* Don't make yyparse think this is eof.  */
2159       value = 1;
2160       break;
2161
2162     case '{':
2163       indent_level++;
2164       value = c;
2165       break;
2166
2167     case '}':
2168       indent_level--;
2169       value = c;
2170       break;
2171
2172     default:
2173       value = c;
2174     }
2175
2176 done:
2177 /*  yylloc.last_line = lineno; */
2178
2179   return value;
2180 }
2181
2182 /* Sets the value of the 'yydebug' variable to VALUE.
2183    This is a function so we don't have to have YYDEBUG defined
2184    in order to build the compiler.  */
2185
2186 void
2187 set_yydebug (value)
2188      int value;
2189 {
2190 #if YYDEBUG != 0
2191   yydebug = value;
2192 #else
2193   warning ("YYDEBUG not defined.");
2194 #endif
2195 }