/* Lexical analyzer for C and Objective C.
- Copyright (C) 1987, 88, 89, 92, 94-98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
+ 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "toplev.h"
#include "intl.h"
#include "ggc.h"
+#include "tm_p.h"
/* MULTIBYTE_CHARS support only works for native compilers.
??? Ideally what we want is to model widechar support after
FILE *finput;
#endif
-extern void yyprint PROTO((FILE *, int, YYSTYPE));
+extern void yyprint PARAMS ((FILE *, int, YYSTYPE));
/* The elements of `ridpointers' are identifier nodes
for the reserved type names and storage classes.
#define UNGETC(c) put_back (c)
struct putback_buffer {
- char *buffer;
+ unsigned char *buffer;
int buffer_size;
int index;
};
static struct putback_buffer putback = {NULL, 0, -1};
+static inline int getch PARAMS ((void));
+
static inline int
getch ()
{
return getc (finput);
}
+static inline void put_back PARAMS ((int));
+
static inline void
put_back (ch)
int ch;
static int end_of_file;
#ifdef HANDLE_GENERIC_PRAGMAS
-static int handle_generic_pragma PROTO((int));
+static int handle_generic_pragma PARAMS ((int));
#endif /* HANDLE_GENERIC_PRAGMAS */
-static int whitespace_cr PROTO((int));
-static int skip_white_space PROTO((int));
-static char *extend_token_buffer PROTO((const char *));
-static int readescape PROTO((int *));
-static void parse_float PROTO((PTR));
+static int whitespace_cr PARAMS ((int));
+static int skip_white_space PARAMS ((int));
+static char *extend_token_buffer PARAMS ((const char *));
+static int readescape PARAMS ((int *));
+static void parse_float PARAMS ((PTR));
+static void extend_token_buffer_to PARAMS ((int));
+static int read_line_number PARAMS ((int *));
\f
/* Do not insert generated code into the source, instead, include it.
This allows us to build gcc automatically even for targets that
ridpointers[(int) RID_CONST] = get_identifier ("const");
ridpointers[(int) RID_RESTRICT] = get_identifier ("restrict");
ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
+ ridpointers[(int) RID_BOUNDED] = get_identifier ("__bounded");
+ ridpointers[(int) RID_UNBOUNDED] = get_identifier ("__unbounded");
ridpointers[(int) RID_AUTO] = get_identifier ("auto");
ridpointers[(int) RID_STATIC] = get_identifier ("static");
ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
UNSET_RESERVED_WORD ("iterator");
UNSET_RESERVED_WORD ("complex");
}
- else if (!flag_isoc9x)
+ else if (!flag_isoc99)
UNSET_RESERVED_WORD ("restrict");
if (flag_no_asm)
\f
/* Iff C is a carriage return, warn about it - if appropriate -
and return nonzero. */
+
static int
whitespace_cr (c)
int c;
static int
pragma_getc ()
{
- return GETC();
+ return GETC ();
}
static void
(if both are defined), in order to give the back
end a chance to override the interpretation of
SYSV style pragmas. */
- if (HANDLE_PRAGMA (getch, put_back,
+ if (HANDLE_PRAGMA (pragma_getc, pragma_ungetc,
IDENTIFIER_POINTER (yylval.ttype)))
goto skipline;
#endif /* HANDLE_PRAGMA */
goto skipline;
}
- if (! ggc_p && !TREE_PERMANENT (yylval.ttype))
- {
- input_filename
- = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
- strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
- }
- else
- input_filename = TREE_STRING_POINTER (yylval.ttype);
+ input_filename = TREE_STRING_POINTER (yylval.ttype);
if (main_input_filename == 0)
main_input_filename = input_filename;
nonnull = 1;
}
if (! nonnull)
- error ("\\x used with no following hex digits");
+ {
+ warning ("\\x used with no following hex digits");
+ return 'x';
+ }
else if (count == 0)
/* Digits are all 0's. Ok. */
;
next token, which screws up feed_input. So just return a null
character. */
-inline int
+static inline int token_getch PARAMS ((void));
+
+static inline int
token_getch ()
{
#if USE_CPPLIB
return GETC ();
}
-inline void
+static inline void token_put_back PARAMS ((int));
+
+static inline void
token_put_back (ch)
int ch;
{
|| (ISALNUM (c) && c != 'l' && c != 'L'
&& c != 'u' && c != 'U'
&& c != 'i' && c != 'I' && c != 'j' && c != 'J'
- && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
+ && (floatflag == NOT_FLOAT
+ || ((base != 16) && (c != 'f') && (c != 'F'))
+ || base == 16)))
{
if (c == '.')
{
type = flag_traditional ? traditional_type : ansi_type;
- if (warn_traditional && traditional_type != ansi_type)
+ /* We assume that constants specified in a non-decimal
+ base are bit patterns, and that the programmer really
+ meant what they wrote. */
+ if (warn_traditional && base == 10
+ && traditional_type != ansi_type)
{
if (TYPE_PRECISION (traditional_type)
!= TYPE_PRECISION (ansi_type))