Integrated preprocessor.

[pf3gnuchains/gcc-fork.git] / gcc / c-lex.c

/* Lexical analyzer for C and Objective C.
   Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
   1998, 1999, 2000 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#include "config.h"
#include "system.h"

#include "rtl.h"
#include "tree.h"
#include "input.h"
#include "output.h"
#include "c-lex.h"
#include "c-tree.h"
#include "flags.h"
#include "timevar.h"
#include "c-pragma.h"
#include "toplev.h"
#include "intl.h"
#include "ggc.h"
#include "tm_p.h"
#include "splay-tree.h"

/* MULTIBYTE_CHARS support only works for native compilers.
   ??? Ideally what we want is to model widechar support after
   the current floating point support.  */
#ifdef CROSS_COMPILE
#undef MULTIBYTE_CHARS
#endif

#ifdef MULTIBYTE_CHARS
#include "mbchar.h"
#include <locale.h>
#endif /* MULTIBYTE_CHARS */
#ifndef GET_ENVIRONMENT
#define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
#endif

#include "cpplib.h"

#if USE_CPPLIB
extern cpp_reader  parse_in;
#else
/* Stream for reading from the input file.  */
FILE *finput;
#endif

/* Private idea of the line number.  See discussion in c_lex().  */
static int lex_lineno;

/* We may keep statistics about how long which files took to compile.  */
static int header_time, body_time;
static splay_tree file_info_tree;

/* Cause the `yydebug' variable to be defined.  */
#define YYDEBUG 1

#if !USE_CPPLIB

struct putback_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 ()
{
  if (putback.index != -1)
    {
      int ch = putback.buffer[putback.index];
      --putback.index;
      return ch;
    }
  return getc (finput);
}

static inline void put_back PARAMS ((int));

static inline void
put_back (ch)
     int ch;
{
  if (ch != EOF)
    {
      if (putback.index == putback.buffer_size - 1)
        {
          putback.buffer_size += 16;
          putback.buffer = xrealloc (putback.buffer, putback.buffer_size);
        }
      putback.buffer[++putback.index] = ch;
    }
}

int linemode;

#endif

/* File used for outputting assembler code.  */
extern FILE *asm_out_file;

#undef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)

/* Number of bytes in a wide character.  */
#define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)

#if !USE_CPPLIB
static int maxtoken;            /* Current nominal length of token buffer.  */
static char *token_buffer;      /* Pointer to token buffer.
                                   Actual allocated length is maxtoken + 2. */
#endif

int indent_level;        /* Number of { minus number of }. */
int pending_lang_change; /* If we need to switch languages - C++ only */
int c_header_level;      /* depth in C headers - C++ only */

/* Nonzero tells yylex to ignore \ in string constants.  */
static int ignore_escape_flag;

static const char *readescape   PARAMS ((const char *, const char *,
                                         unsigned int *));
static const char *read_ucs     PARAMS ((const char *, const char *,
                                         unsigned int *, int));
static void parse_float         PARAMS ((PTR));
static tree lex_number          PARAMS ((const char *, unsigned int));
static tree lex_string          PARAMS ((const char *, unsigned int, int));
static tree lex_charconst       PARAMS ((const char *, unsigned int, int));
static void update_header_times PARAMS ((const char *));
static int dump_one_header      PARAMS ((splay_tree_node, void *));

#if !USE_CPPLIB
static int skip_white_space             PARAMS ((int));
static char *extend_token_buffer        PARAMS ((const char *));
static void extend_token_buffer_to      PARAMS ((int));
static int read_line_number             PARAMS ((int *));
static void process_directive           PARAMS ((void));
#else
static void cb_ident            PARAMS ((cpp_reader *, const unsigned char *,
                                         unsigned int));
static void cb_enter_file       PARAMS ((cpp_reader *));
static void cb_leave_file       PARAMS ((cpp_reader *));
static void cb_rename_file      PARAMS ((cpp_reader *));
#endif

\f
const char *
init_c_lex (filename)
     const char *filename;
{
  struct c_fileinfo *toplevel;

  /* Set up filename timing.  Must happen before cpp_start_read.  */
  file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
                                   0,
                                   (splay_tree_delete_value_fn)free);
  toplevel = get_fileinfo ("<top level>");
  if (flag_detailed_statistics)
    {
      header_time = 0;
      body_time = get_run_time ();
      toplevel->time = body_time;
    }
  
#ifdef MULTIBYTE_CHARS
  /* Change to the native locale for multibyte conversions.  */
  setlocale (LC_CTYPE, "");
  GET_ENVIRONMENT (literal_codeset, "LANG");
#endif

#if !USE_CPPLIB
  /* Open input file.  */
  if (filename == 0 || !strcmp (filename, "-"))
    {
      finput = stdin;
      filename = "stdin";
    }
  else
    finput = fopen (filename, "r");
  if (finput == 0)
    pfatal_with_name (filename);

#ifdef IO_BUFFER_SIZE
  setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
#endif
#else /* !USE_CPPLIB */

  parse_in.cb.ident = cb_ident;
  parse_in.cb.enter_file = cb_enter_file;
  parse_in.cb.leave_file = cb_leave_file;
  parse_in.cb.rename_file = cb_rename_file;

  /* Make sure parse_in.digraphs matches flag_digraphs.  */
  CPP_OPTION (&parse_in, digraphs) = flag_digraphs;

  if (! cpp_start_read (&parse_in, 0 /* no printer */, filename))
    abort ();

  if (filename == 0 || !strcmp (filename, "-"))
    filename = "stdin";
#endif

#if !USE_CPPLIB
  maxtoken = 40;
  token_buffer = (char *) xmalloc (maxtoken + 2);
#endif
  /* Start it at 0, because check_newline is called at the very beginning
     and will increment it to 1.  */
  lineno = lex_lineno = 0;

  return filename;
}

struct c_fileinfo *
get_fileinfo (name)
     const char *name;
{
  splay_tree_node n;
  struct c_fileinfo *fi;

  n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
  if (n)
    return (struct c_fileinfo *) n->value;

  fi = (struct c_fileinfo *) xmalloc (sizeof (struct c_fileinfo));
  fi->time = 0;
  fi->interface_only = 0;
  fi->interface_unknown = 1;
  splay_tree_insert (file_info_tree, (splay_tree_key) name,
                     (splay_tree_value) fi);
  return fi;
}

static void
update_header_times (name)
     const char *name;
{
  /* Changing files again.  This means currently collected time
     is charged against header time, and body time starts back at 0.  */
  if (flag_detailed_statistics)
    {
      int this_time = get_run_time ();
      struct c_fileinfo *file = get_fileinfo (name);
      header_time += this_time - body_time;
      file->time += this_time - body_time;
      body_time = this_time;
    }
}

static int
dump_one_header (n, dummy)
     splay_tree_node n;
     void *dummy ATTRIBUTE_UNUSED;
{
  print_time ((const char *) n->key,
              ((struct c_fileinfo *) n->value)->time);
  return 0;
}

void
dump_time_statistics ()
{
  struct c_fileinfo *file = get_fileinfo (input_filename);
  int this_time = get_run_time ();
  file->time += this_time - body_time;

  fprintf (stderr, "\n******\n");
  print_time ("header files (total)", header_time);
  print_time ("main file (total)", this_time - body_time);
  fprintf (stderr, "ratio = %g : 1\n",
           (double)header_time / (double)(this_time - body_time));
  fprintf (stderr, "\n******\n");

  splay_tree_foreach (file_info_tree, dump_one_header, 0);
}

#if !USE_CPPLIB

/* If C is not whitespace, return C.
   Otherwise skip whitespace and return first nonwhite char read.  */

static int
skip_white_space (c)
     register int c;
{
  for (;;)
    {
      switch (c)
        {
          /* There is no need to process comments, backslash-newline,
             or \r here.  None can occur in the output of cpp.  */

        case '\n':
          if (linemode)
            {
              put_back (c);
              return EOF;
            }
          c = check_newline ();
          break;

          /* Per C99, horizontal whitespace is just these four characters.  */
        case ' ':
        case '\t':
        case '\f':
        case '\v':
            c = getch ();
          break;

        case '\\':
          error ("stray '\\' in program");
          c = getch ();
          break;

        default:
          return (c);
        }
    }
}

/* Skips all of the white space at the current location in the input file.  */

void
position_after_white_space ()
{
  register int c;

  c = getch ();

  put_back (skip_white_space (c));
}

/* Make the token buffer longer, preserving the data in it.
   P should point to just beyond the last valid character in the old buffer.
   The value we return is a pointer to the new buffer
   at a place corresponding to P.  */

static void
extend_token_buffer_to (size)
     int size;
{
  do
    maxtoken = maxtoken * 2 + 10;
  while (maxtoken < size);
  token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
}

static char *
extend_token_buffer (p)
     const char *p;
{
  int offset = p - token_buffer;
  extend_token_buffer_to (offset);
  return token_buffer + offset;
}
\f

static int
read_line_number (num)
     int *num;
{
  tree value;
  enum cpp_ttype token = c_lex (&value);

  if (token == CPP_NUMBER && TREE_CODE (value) == INTEGER_CST)
    {
      *num = TREE_INT_CST_LOW (value);
      return 1;
    }
  else
    {
      if (token != CPP_EOF)
        error ("invalid #-line");
      return 0;
    }
}

/* At the beginning of a line, increment the line number
   and process any #-directive on this line.
   If the line is a #-directive, read the entire line and return a newline.
   Otherwise, return the line's first non-whitespace character.  */

int
check_newline ()
{
  register int c;

  /* Loop till we get a nonblank, non-directive line.  */
  for (;;)
    {
      /* Read first nonwhite char on the line.  */
      do
        c = getch ();
      while (c == ' ' || c == '\t');

      lex_lineno++;
      if (c == '#')
        {
          process_directive ();
          return '\n';
        }

      else if (c != '\n')
        break;
    }
  return c;
}

static void
process_directive ()
{
  enum cpp_ttype token;
  tree value;
  int saw_line;
  enum { act_none, act_push, act_pop } action;
  int action_number, l;
  char *new_file;
#ifndef NO_IMPLICIT_EXTERN_C
  int entering_c_header;
#endif
  
  /* Don't read beyond this line.  */
  saw_line = 0;
  linemode = 1;
  
  token = c_lex (&value);

  if (token == CPP_NAME)
    {
      /* If a letter follows, then if the word here is `line', skip
         it and ignore it; otherwise, ignore the line, with an error
         if the word isn't `pragma'.  */

      const char *name = IDENTIFIER_POINTER (value);

      if (!strcmp (name, "pragma"))
        {
          dispatch_pragma ();
          goto skipline;

#if 0
#ifdef HANDLE_PRAGMA
          /* We invoke HANDLE_PRAGMA before HANDLE_GENERIC_PRAGMAS
             (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, IDENTIFIER_POINTER (value)))
            goto skipline;
#endif /* HANDLE_PRAGMA */
#endif
        }
      else if (!strcmp (name, "define"))
        {
          debug_define (lex_lineno, GET_DIRECTIVE_LINE ());
          goto skipline;
        }
      else if (!strcmp (name, "undef"))
        {
          debug_undef (lex_lineno, GET_DIRECTIVE_LINE ());
          goto skipline;
        }
      else if (!strcmp (name, "line"))
        {
          saw_line = 1;
          token = c_lex (&value);
          goto linenum;
        }
      else if (!strcmp (name, "ident"))
        {
          /* #ident.  We expect a string constant here.
             The pedantic warning and syntax error are now in cpp.  */

          token = c_lex (&value);
          if (token != CPP_STRING || TREE_CODE (value) != STRING_CST)
            goto skipline;

#ifdef ASM_OUTPUT_IDENT
          if (! flag_no_ident)
            {
              ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (value));
            }
#endif

          /* Skip the rest of this line.  */
          goto skipline;
        }

      error ("undefined or invalid # directive `%s'", name);
      goto skipline;
    }

  /* If the # is the only nonwhite char on the line,
     just ignore it.  Check the new newline.  */
  if (token == CPP_EOF)
    goto skipline;

linenum:
  /* Here we have either `#line' or `# <nonletter>'.
     In either case, it should be a line number; a digit should follow.  */

  if (token != CPP_NUMBER || TREE_CODE (value) != INTEGER_CST)
    {
      error ("invalid #-line");
      goto skipline;
    }

  /* subtract one, because it is the following line that
     gets the specified number */

  l = TREE_INT_CST_LOW (value) - 1;

  /* More follows: it must be a string constant (filename).
     It would be neat to use cpplib to quickly process the string, but
     (1) we don't have a handy tokenization of the string, and
     (2) I don't know how well that would work in the presense
     of filenames that contain wide characters.  */

  if (saw_line)
    {
      /* Don't treat \ as special if we are processing #line 1 "...".
         If you want it to be treated specially, use # 1 "...".  */
      ignore_escape_flag = 1;
    }

  /* Read the string constant.  */
  token = c_lex (&value);

  ignore_escape_flag = 0;

  if (token == CPP_EOF)
    {
      /* No more: store the line number and check following line.  */
      lex_lineno = l;
      goto skipline;
    }

  if (token != CPP_STRING || TREE_CODE (value) != STRING_CST)
    {
      error ("invalid #line");
      goto skipline;
    }

  new_file = TREE_STRING_POINTER (value);

  if (main_input_filename == 0)
    main_input_filename = new_file;

  action = act_none;
  action_number = 0;

  /* Each change of file name
     reinitializes whether we are now in a system header.  */
  in_system_header = 0;

  if (!read_line_number (&action_number))
    {
      /* Update the name in the top element of input_file_stack.  */
      if (input_file_stack)
        input_file_stack->name = input_filename;
    }

  /* `1' after file name means entering new file.
     `2' after file name means just left a file.  */

  if (action_number == 1)
    {
      action = act_push;
      read_line_number (&action_number);
    }
  else if (action_number == 2)
    {
      action = act_pop;
      read_line_number (&action_number);
    }
  if (action_number == 3)
    {
      /* `3' after file name means this is a system header file.  */
      in_system_header = 1;
      read_line_number (&action_number);
    }
#ifndef NO_IMPLICIT_EXTERN_C
  if (action_number == 4)
    {
      /* `4' after file name means this is a C header file.  */
      entering_c_header = 1;
      read_line_number (&action_number);
    }
#endif

  /* Do the actions implied by the preceding numbers.  */
  if (action == act_push)
    {
      lineno = lex_lineno;
      push_srcloc (input_filename, 1);
      input_file_stack->indent_level = indent_level;
      debug_start_source_file (input_filename);
#ifndef NO_IMPLICIT_EXTERN_C
      if (c_header_level)
        ++c_header_level;
      else if (entering_c_header)
        {
          c_header_level = 1;
          ++pending_lang_change;
        }
#endif
    }
  else if (action == act_pop)
    {
      /* Popping out of a file.  */
      if (input_file_stack->next)
        {
#ifndef NO_IMPLICIT_EXTERN_C
          if (c_header_level && --c_header_level == 0)
            {
              if (entering_c_header)
                warning ("badly nested C headers from preprocessor");
              --pending_lang_change;
            }
#endif
#if 0
          if (indent_level != input_file_stack->indent_level)
            {
              warning_with_file_and_line
                (input_filename, lex_lineno,
                 "This file contains more '%c's than '%c's.",
                 indent_level > input_file_stack->indent_level ? '{' : '}',
                 indent_level > input_file_stack->indent_level ? '}' : '{');
            }
#endif
          pop_srcloc ();
          debug_end_source_file (input_file_stack->line);
        }
      else
        error ("#-lines for entering and leaving files don't match");
    }

  update_header_times (new_file);

  input_filename = new_file;
  lex_lineno = l;

  /* Hook for C++.  */
  extract_interface_info ();

  /* skip the rest of this line.  */
 skipline:
  linemode = 0;

  while (getch () != '\n');
}
#else /* USE_CPPLIB */

/* Not yet handled: #pragma, #define, #undef.
   No need to deal with linemarkers under normal conditions.  */

static void
cb_ident (pfile, str, len)
     cpp_reader *pfile ATTRIBUTE_UNUSED;
     const unsigned char *str;
     unsigned int len;
{
#ifdef ASM_OUTPUT_IDENT
  if (! flag_no_ident)
    {
      /* Convert escapes in the string.  */
      tree value = lex_string ((const char *)str, len, 0);
      ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (value));
    }
#endif
}

static void
cb_enter_file (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *ip = CPP_BUFFER (pfile);
  /* Bleah, need a better interface to this.  */
  const char *flags = cpp_syshdr_flags (pfile, ip);

  /* Mustn't stack the main buffer on the input stack.  (Ick.)  */
  if (ip->prev)
    {
      lex_lineno = lineno = ip->prev->lineno - 1;
      push_srcloc (ggc_alloc_string (ip->nominal_fname, -1), 1);
      input_file_stack->indent_level = indent_level;
      debug_start_source_file (ip->nominal_fname);
    }
  else
    lex_lineno = 1;

  update_header_times (ip->nominal_fname);

  /* Hook for C++.  */
  extract_interface_info ();

  in_system_header = (flags[0] != 0);
#ifndef NO_IMPLICIT_EXTERN_C
  if (c_header_level)
    ++c_header_level;
  else if (flags[2] != 0)
    {
      c_header_level = 1;
      ++pending_lang_change;
    }
#endif
}

static void
cb_leave_file (pfile)
     cpp_reader *pfile;
{
  /* Bleah, need a better interface to this.  */
  const char *flags = cpp_syshdr_flags (pfile, CPP_BUFFER (pfile));
#if 0
  if (indent_level != input_file_stack->indent_level)
    {
      warning_with_file_and_line
        (input_filename, lex_lineno,
         "This file contains more '%c's than '%c's.",
         indent_level > input_file_stack->indent_level ? '{' : '}',
         indent_level > input_file_stack->indent_level ? '}' : '{');
    }
#endif
  /* We get called for the main buffer, but we mustn't pop it.  */
  if (input_file_stack->next)
    pop_srcloc ();
  in_system_header = (flags[0] != 0);
#ifndef NO_IMPLICIT_EXTERN_C
  if (c_header_level && --c_header_level == 0)
    {
      if (flags[2] != 0)
        warning ("badly nested C headers from preprocessor");
      --pending_lang_change;
    }
#endif
  lex_lineno = CPP_BUFFER (pfile)->lineno;
  debug_end_source_file (input_file_stack->line);

  update_header_times (input_file_stack->name);
  /* Hook for C++.  */
  extract_interface_info ();
}

static void
cb_rename_file (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *ip = CPP_BUFFER (pfile);
  /* Bleah, need a better interface to this.  */
  const char *flags = cpp_syshdr_flags (pfile, ip);
  input_filename = ggc_alloc_string (ip->nominal_fname, -1);
  lex_lineno = ip->lineno;
  in_system_header = (flags[0] != 0);

  update_header_times (ip->nominal_fname);
  /* Hook for C++.  */
  extract_interface_info ();
}
#endif /* USE_CPPLIB */

/* Parse a '\uNNNN' or '\UNNNNNNNN' sequence.

   [lex.charset]: The character designated by the universal-character-name 
   \UNNNNNNNN is that character whose character short name in ISO/IEC 10646
   is NNNNNNNN; the character designated by the universal-character-name
   \uNNNN is that character whose character short name in ISO/IEC 10646 is
   0000NNNN. If the hexadecimal value for a universal character name is
   less than 0x20 or in the range 0x7F-0x9F (inclusive), or if the
   universal character name designates a character in the basic source
   character set, then the program is ill-formed.

   We assume that wchar_t is Unicode, so we don't need to do any
   mapping.  Is this ever wrong?  */

static const char *
read_ucs (p, limit, cptr, length)
     const char *p;
     const char *limit;
     unsigned int *cptr;
     int length;
{
  unsigned int code = 0;
  int c;

  for (; length; --length)
    {
      if (p >= limit)
        {
          error ("incomplete universal-character-name");
          break;
        }

      c = *p++;
      if (! ISXDIGIT (c))
        {
          error ("non hex digit '%c' in universal-character-name", c);
          p--;
          break;
        }

      code <<= 4;
      if (c >= 'a' && c <= 'f')
        code += c - 'a' + 10;
      if (c >= 'A' && c <= 'F')
        code += c - 'A' + 10;
      if (c >= '0' && c <= '9')
        code += c - '0';
    }

#ifdef TARGET_EBCDIC
  sorry ("universal-character-name on EBCDIC target");
  *cptr = 0x3f;  /* EBCDIC invalid character */
  return p;
#endif

  if (code > 0x9f && !(code & 0x80000000))
    /* True extended character, OK.  */;
  else if (code >= 0x20 && code < 0x7f)
    {
      /* ASCII printable character.  The C character set consists of all of
         these except $, @ and `.  We use hex escapes so that this also
         works with EBCDIC hosts.  */
      if (code != 0x24 && code != 0x40 && code != 0x60)
        error ("universal-character-name used for '%c'", code);
    }
  else
    error ("invalid universal-character-name");

  *cptr = code;
  return p;
}

/* Read an escape sequence and write its character equivalent into *CPTR.
   P is the input pointer, which is just after the backslash.  LIMIT
   is how much text we have.
   Returns the updated input pointer.  */

static const char *
readescape (p, limit, cptr)
     const char *p;
     const char *limit;
     unsigned int *cptr;
{
  unsigned int c, code, count;
  unsigned firstdig = 0;
  int nonnull;

  if (p == limit)
    {
      /* cpp has already issued an error for this.  */
      *cptr = 0;
      return p;
    }

  c = *p++;

  switch (c)
    {
    case 'x':
      if (warn_traditional && !in_system_header)
        warning ("the meaning of `\\x' varies with -traditional");

      if (flag_traditional)
        {
          *cptr = 'x';
          return p;
        }

      code = 0;
      count = 0;
      nonnull = 0;
      while (p < limit)
        {
          c = *p++;
          if (! ISXDIGIT (c))
            {
              p--;
              break;
            }
          code *= 16;
          if (c >= 'a' && c <= 'f')
            code += c - 'a' + 10;
          if (c >= 'A' && c <= 'F')
            code += c - 'A' + 10;
          if (c >= '0' && c <= '9')
            code += c - '0';
          if (code != 0 || count != 0)
            {
              if (count == 0)
                firstdig = code;
              count++;
            }
          nonnull = 1;
        }
      if (! nonnull)
        {
          warning ("\\x used with no following hex digits");
          *cptr = 'x';
          return p;
        }
      else if (count == 0)
        /* Digits are all 0's.  Ok.  */
        ;
      else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
               || (count > 1
                   && (((unsigned)1
                        << (TYPE_PRECISION (integer_type_node)
                            - (count - 1) * 4))
                       <= firstdig)))
        pedwarn ("hex escape out of range");
      *cptr = code;
      return p;

    case '0':  case '1':  case '2':  case '3':  case '4':
    case '5':  case '6':  case '7':
      code = 0;
      for (count = 0; count < 3; count++)
        {
          if (c < '0' || c > '7')
            {
              p--;
              break;
            }
          code = (code * 8) + (c - '0');
          if (p == limit)
            break;
          c = *p++;
        }

      if (count == 3)
        p--;

      *cptr = code;
      return p;

    case '\\': case '\'': case '"': case '?':
      *cptr = c;
      return p;

    case 'n': *cptr = TARGET_NEWLINE;   return p;
    case 't': *cptr = TARGET_TAB;       return p;
    case 'r': *cptr = TARGET_CR;        return p;
    case 'f': *cptr = TARGET_FF;        return p;
    case 'b': *cptr = TARGET_BS;        return p;
    case 'v': *cptr = TARGET_VT;        return p;
    case 'a':
      if (warn_traditional && !in_system_header)
        warning ("the meaning of '\\a' varies with -traditional");
      *cptr = flag_traditional ? c : TARGET_BELL;
      return p;

      /* Warnings and support checks handled by read_ucs().  */
    case 'u': case 'U':
      if (c_language != clk_cplusplus && !flag_isoc99)
        break;

      if (warn_traditional && !in_system_header)
        warning ("the meaning of '\\%c' varies with -traditional", c);

      return read_ucs (p, limit, cptr, c == 'u' ? 4 : 8);
      
    case 'e': case 'E':
      if (pedantic)
        pedwarn ("non-ISO-standard escape sequence, '\\%c'", c);
      *cptr = TARGET_ESC; return p;

      /* '\(', etc, are used at beginning of line to avoid confusing Emacs.
         '\%' is used to prevent SCCS from getting confused.  */
    case '(': case '{': case '[': case '%':
      if (pedantic)
        pedwarn ("unknown escape sequence '\\%c'", c);
      *cptr = c;
      return p;
    }

  if (ISGRAPH (c))
    pedwarn ("unknown escape sequence '\\%c'", c);
  else
    pedwarn ("unknown escape sequence: '\\' followed by char 0x%.2x", c);

  *cptr = c;
  return p;
}

#if 0 /* not yet */
/* Returns nonzero if C is a universal-character-name.  Give an error if it
   is not one which may appear in an identifier, as per [extendid].

   Note that extended character support in identifiers has not yet been
   implemented.  It is my personal opinion that this is not a desirable
   feature.  Portable code cannot count on support for more than the basic
   identifier character set.  */

static inline int
is_extended_char (c)
     int c;
{
#ifdef TARGET_EBCDIC
  return 0;
#else
  /* ASCII.  */
  if (c < 0x7f)
    return 0;

  /* None of the valid chars are outside the Basic Multilingual Plane (the
     low 16 bits).  */
  if (c > 0xffff)
    {
      error ("universal-character-name '\\U%08x' not valid in identifier", c);
      return 1;
    }
  
  /* Latin */
  if ((c >= 0x00c0 && c <= 0x00d6)
      || (c >= 0x00d8 && c <= 0x00f6)
      || (c >= 0x00f8 && c <= 0x01f5)
      || (c >= 0x01fa && c <= 0x0217)
      || (c >= 0x0250 && c <= 0x02a8)
      || (c >= 0x1e00 && c <= 0x1e9a)
      || (c >= 0x1ea0 && c <= 0x1ef9))
    return 1;

  /* Greek */
  if ((c == 0x0384)
      || (c >= 0x0388 && c <= 0x038a)
      || (c == 0x038c)
      || (c >= 0x038e && c <= 0x03a1)
      || (c >= 0x03a3 && c <= 0x03ce)
      || (c >= 0x03d0 && c <= 0x03d6)
      || (c == 0x03da)
      || (c == 0x03dc)
      || (c == 0x03de)
      || (c == 0x03e0)
      || (c >= 0x03e2 && c <= 0x03f3)
      || (c >= 0x1f00 && c <= 0x1f15)
      || (c >= 0x1f18 && c <= 0x1f1d)
      || (c >= 0x1f20 && c <= 0x1f45)
      || (c >= 0x1f48 && c <= 0x1f4d)
      || (c >= 0x1f50 && c <= 0x1f57)
      || (c == 0x1f59)
      || (c == 0x1f5b)
      || (c == 0x1f5d)
      || (c >= 0x1f5f && c <= 0x1f7d)
      || (c >= 0x1f80 && c <= 0x1fb4)
      || (c >= 0x1fb6 && c <= 0x1fbc)
      || (c >= 0x1fc2 && c <= 0x1fc4)
      || (c >= 0x1fc6 && c <= 0x1fcc)
      || (c >= 0x1fd0 && c <= 0x1fd3)
      || (c >= 0x1fd6 && c <= 0x1fdb)
      || (c >= 0x1fe0 && c <= 0x1fec)
      || (c >= 0x1ff2 && c <= 0x1ff4)
      || (c >= 0x1ff6 && c <= 0x1ffc))
    return 1;

  /* Cyrillic */
  if ((c >= 0x0401 && c <= 0x040d)
      || (c >= 0x040f && c <= 0x044f)
      || (c >= 0x0451 && c <= 0x045c)
      || (c >= 0x045e && c <= 0x0481)
      || (c >= 0x0490 && c <= 0x04c4)
      || (c >= 0x04c7 && c <= 0x04c8)
      || (c >= 0x04cb && c <= 0x04cc)
      || (c >= 0x04d0 && c <= 0x04eb)
      || (c >= 0x04ee && c <= 0x04f5)
      || (c >= 0x04f8 && c <= 0x04f9))
    return 1;

  /* Armenian */
  if ((c >= 0x0531 && c <= 0x0556)
      || (c >= 0x0561 && c <= 0x0587))
    return 1;

  /* Hebrew */
  if ((c >= 0x05d0 && c <= 0x05ea)
      || (c >= 0x05f0 && c <= 0x05f4))
    return 1;

  /* Arabic */
  if ((c >= 0x0621 && c <= 0x063a)
      || (c >= 0x0640 && c <= 0x0652)
      || (c >= 0x0670 && c <= 0x06b7)
      || (c >= 0x06ba && c <= 0x06be)
      || (c >= 0x06c0 && c <= 0x06ce)
      || (c >= 0x06e5 && c <= 0x06e7))
    return 1;

  /* Devanagari */
  if ((c >= 0x0905 && c <= 0x0939)
      || (c >= 0x0958 && c <= 0x0962))
    return 1;

  /* Bengali */
  if ((c >= 0x0985 && c <= 0x098c)
      || (c >= 0x098f && c <= 0x0990)
      || (c >= 0x0993 && c <= 0x09a8)
      || (c >= 0x09aa && c <= 0x09b0)
      || (c == 0x09b2)
      || (c >= 0x09b6 && c <= 0x09b9)
      || (c >= 0x09dc && c <= 0x09dd)
      || (c >= 0x09df && c <= 0x09e1)
      || (c >= 0x09f0 && c <= 0x09f1))
    return 1;

  /* Gurmukhi */
  if ((c >= 0x0a05 && c <= 0x0a0a)
      || (c >= 0x0a0f && c <= 0x0a10)
      || (c >= 0x0a13 && c <= 0x0a28)
      || (c >= 0x0a2a && c <= 0x0a30)
      || (c >= 0x0a32 && c <= 0x0a33)
      || (c >= 0x0a35 && c <= 0x0a36)
      || (c >= 0x0a38 && c <= 0x0a39)
      || (c >= 0x0a59 && c <= 0x0a5c)
      || (c == 0x0a5e))
    return 1;

  /* Gujarati */
  if ((c >= 0x0a85 && c <= 0x0a8b)
      || (c == 0x0a8d)
      || (c >= 0x0a8f && c <= 0x0a91)
      || (c >= 0x0a93 && c <= 0x0aa8)
      || (c >= 0x0aaa && c <= 0x0ab0)
      || (c >= 0x0ab2 && c <= 0x0ab3)
      || (c >= 0x0ab5 && c <= 0x0ab9)
      || (c == 0x0ae0))
    return 1;

  /* Oriya */
  if ((c >= 0x0b05 && c <= 0x0b0c)
      || (c >= 0x0b0f && c <= 0x0b10)
      || (c >= 0x0b13 && c <= 0x0b28)
      || (c >= 0x0b2a && c <= 0x0b30)
      || (c >= 0x0b32 && c <= 0x0b33)
      || (c >= 0x0b36 && c <= 0x0b39)
      || (c >= 0x0b5c && c <= 0x0b5d)
      || (c >= 0x0b5f && c <= 0x0b61))
    return 1;

  /* Tamil */
  if ((c >= 0x0b85 && c <= 0x0b8a)
      || (c >= 0x0b8e && c <= 0x0b90)
      || (c >= 0x0b92 && c <= 0x0b95)
      || (c >= 0x0b99 && c <= 0x0b9a)
      || (c == 0x0b9c)
      || (c >= 0x0b9e && c <= 0x0b9f)
      || (c >= 0x0ba3 && c <= 0x0ba4)
      || (c >= 0x0ba8 && c <= 0x0baa)
      || (c >= 0x0bae && c <= 0x0bb5)
      || (c >= 0x0bb7 && c <= 0x0bb9))
    return 1;

  /* Telugu */
  if ((c >= 0x0c05 && c <= 0x0c0c)
      || (c >= 0x0c0e && c <= 0x0c10)
      || (c >= 0x0c12 && c <= 0x0c28)
      || (c >= 0x0c2a && c <= 0x0c33)
      || (c >= 0x0c35 && c <= 0x0c39)
      || (c >= 0x0c60 && c <= 0x0c61))
    return 1;

  /* Kannada */
  if ((c >= 0x0c85 && c <= 0x0c8c)
      || (c >= 0x0c8e && c <= 0x0c90)
      || (c >= 0x0c92 && c <= 0x0ca8)
      || (c >= 0x0caa && c <= 0x0cb3)
      || (c >= 0x0cb5 && c <= 0x0cb9)
      || (c >= 0x0ce0 && c <= 0x0ce1))
    return 1;

  /* Malayalam */
  if ((c >= 0x0d05 && c <= 0x0d0c)
      || (c >= 0x0d0e && c <= 0x0d10)
      || (c >= 0x0d12 && c <= 0x0d28)
      || (c >= 0x0d2a && c <= 0x0d39)
      || (c >= 0x0d60 && c <= 0x0d61))
    return 1;

  /* Thai */
  if ((c >= 0x0e01 && c <= 0x0e30)
      || (c >= 0x0e32 && c <= 0x0e33)
      || (c >= 0x0e40 && c <= 0x0e46)
      || (c >= 0x0e4f && c <= 0x0e5b))
    return 1;

  /* Lao */
  if ((c >= 0x0e81 && c <= 0x0e82)
      || (c == 0x0e84)
      || (c == 0x0e87)
      || (c == 0x0e88)
      || (c == 0x0e8a)
      || (c == 0x0e0d)
      || (c >= 0x0e94 && c <= 0x0e97)
      || (c >= 0x0e99 && c <= 0x0e9f)
      || (c >= 0x0ea1 && c <= 0x0ea3)
      || (c == 0x0ea5)
      || (c == 0x0ea7)
      || (c == 0x0eaa)
      || (c == 0x0eab)
      || (c >= 0x0ead && c <= 0x0eb0)
      || (c == 0x0eb2)
      || (c == 0x0eb3)
      || (c == 0x0ebd)
      || (c >= 0x0ec0 && c <= 0x0ec4)
      || (c == 0x0ec6))
    return 1;

  /* Georgian */
  if ((c >= 0x10a0 && c <= 0x10c5)
      || (c >= 0x10d0 && c <= 0x10f6))
    return 1;

  /* Hiragana */
  if ((c >= 0x3041 && c <= 0x3094)
      || (c >= 0x309b && c <= 0x309e))
    return 1;

  /* Katakana */
  if ((c >= 0x30a1 && c <= 0x30fe))
    return 1;

  /* Bopmofo */
  if ((c >= 0x3105 && c <= 0x312c))
    return 1;

  /* Hangul */
  if ((c >= 0x1100 && c <= 0x1159)
      || (c >= 0x1161 && c <= 0x11a2)
      || (c >= 0x11a8 && c <= 0x11f9))
    return 1;

  /* CJK Unified Ideographs */
  if ((c >= 0xf900 && c <= 0xfa2d)
      || (c >= 0xfb1f && c <= 0xfb36)
      || (c >= 0xfb38 && c <= 0xfb3c)
      || (c == 0xfb3e)
      || (c >= 0xfb40 && c <= 0xfb41)
      || (c >= 0xfb42 && c <= 0xfb44)
      || (c >= 0xfb46 && c <= 0xfbb1)
      || (c >= 0xfbd3 && c <= 0xfd3f)
      || (c >= 0xfd50 && c <= 0xfd8f)
      || (c >= 0xfd92 && c <= 0xfdc7)
      || (c >= 0xfdf0 && c <= 0xfdfb)
      || (c >= 0xfe70 && c <= 0xfe72)
      || (c == 0xfe74)
      || (c >= 0xfe76 && c <= 0xfefc)
      || (c >= 0xff21 && c <= 0xff3a)
      || (c >= 0xff41 && c <= 0xff5a)
      || (c >= 0xff66 && c <= 0xffbe)
      || (c >= 0xffc2 && c <= 0xffc7)
      || (c >= 0xffca && c <= 0xffcf)
      || (c >= 0xffd2 && c <= 0xffd7)
      || (c >= 0xffda && c <= 0xffdc)
      || (c >= 0x4e00 && c <= 0x9fa5))
    return 1;

  error ("universal-character-name '\\u%04x' not valid in identifier", c);
  return 1;
#endif
}

/* Add the UTF-8 representation of C to the token_buffer.  */

static void
utf8_extend_token (c)
     int c;
{
  int shift, mask;

  if      (c <= 0x0000007f)
    {
      extend_token (c);
      return;
    }
  else if (c <= 0x000007ff)
    shift = 6, mask = 0xc0;
  else if (c <= 0x0000ffff)
    shift = 12, mask = 0xe0;
  else if (c <= 0x001fffff)
    shift = 18, mask = 0xf0;
  else if (c <= 0x03ffffff)
    shift = 24, mask = 0xf8;
  else
    shift = 30, mask = 0xfc;

  extend_token (mask | (c >> shift));
  do
    {
      shift -= 6;
      extend_token ((unsigned char) (0x80 | (c >> shift)));
    }
  while (shift);
}
#endif

#if 0
struct try_type
{
  tree *node_var;
  char unsigned_flag;
  char long_flag;
  char long_long_flag;
};

struct try_type type_sequence[] =
{
  { &integer_type_node, 0, 0, 0},
  { &unsigned_type_node, 1, 0, 0},
  { &long_integer_type_node, 0, 1, 0},
  { &long_unsigned_type_node, 1, 1, 0},
  { &long_long_integer_type_node, 0, 1, 1},
  { &long_long_unsigned_type_node, 1, 1, 1}
};
#endif /* 0 */
\f
struct pf_args
{
  /* Input */
  const char *str;
  int fflag;
  int lflag;
  int base;
  /* Output */
  int conversion_errno;
  REAL_VALUE_TYPE value;
  tree type;
};
 
static void
parse_float (data)
  PTR data;
{
  struct pf_args * args = (struct pf_args *) data;
  const char *typename;

  args->conversion_errno = 0;
  args->type = double_type_node;
  typename = "double";

  /* The second argument, machine_mode, of REAL_VALUE_ATOF
     tells the desired precision of the binary result
     of decimal-to-binary conversion.  */

  if (args->fflag)
    {
      if (args->lflag)
        error ("both 'f' and 'l' suffixes on floating constant");

      args->type = float_type_node;
      typename = "float";
    }
  else if (args->lflag)
    {
      args->type = long_double_type_node;
      typename = "long double";
    }
  else if (flag_single_precision_constant)
    {
      args->type = float_type_node;
      typename = "float";
    }

  errno = 0;
  if (args->base == 16)
    args->value = REAL_VALUE_HTOF (args->str, TYPE_MODE (args->type));
  else
    args->value = REAL_VALUE_ATOF (args->str, TYPE_MODE (args->type));

  args->conversion_errno = errno;
  /* A diagnostic is required here by some ISO C testsuites.
     This is not pedwarn, because some people don't want
     an error for this.  */
  if (REAL_VALUE_ISINF (args->value) && pedantic)
    warning ("floating point number exceeds range of '%s'", typename);
}
 
int
c_lex (value)
     tree *value;
{
#if USE_CPPLIB
  const cpp_token *tok;
  enum cpp_ttype type;

  retry:
  timevar_push (TV_CPP);
  tok = cpp_get_token (&parse_in);
  timevar_pop (TV_CPP);

  /* The C++ front end does horrible things with the current line
     number.  To ensure an accurate line number, we must reset it
     every time we return a token.  If we reset it from tok->line
     every time, we'll get line numbers inside macros referring to the
     macro definition; this is nice, but we don't want to change the
     behavior until integrated mode is the only option.  So we keep our
     own idea of the line number, and reset it from tok->line at each
     new line (which never happens inside a macro).  */
  if (tok->flags & BOL)
    lex_lineno = tok->line;

  *value = NULL_TREE;
  lineno = lex_lineno;
  type = tok->type;
  switch (type)
    {
    case CPP_OPEN_BRACE:  indent_level++;  break;
    case CPP_CLOSE_BRACE: indent_level--;  break;

    /* Issue this error here, where we can get at tok->val.aux.  */
    case CPP_OTHER:
      if (ISGRAPH (tok->val.aux))
        error ("stray '%c' in program", tok->val.aux);
      else
        error ("stray '\\%#o' in program", tok->val.aux);
      goto retry;
      
    case CPP_DEFINED:
      type = CPP_NAME;
    case CPP_NAME:
      *value = get_identifier ((const char *)tok->val.node->name);
      break;

    case CPP_INT:
    case CPP_FLOAT:
    case CPP_NUMBER:
      *value = lex_number ((const char *)tok->val.str.text, tok->val.str.len);
      break;

    case CPP_CHAR:
    case CPP_WCHAR:
      *value = lex_charconst ((const char *)tok->val.str.text,
                              tok->val.str.len, tok->type == CPP_WCHAR);
      break;

    case CPP_STRING:
    case CPP_WSTRING:
    case CPP_OSTRING:
      *value = lex_string ((const char *)tok->val.str.text,
                           tok->val.str.len, tok->type == CPP_WSTRING);
      break;

      /* These tokens should not be visible outside cpplib.  */
    case CPP_HEADER_NAME:
    case CPP_COMMENT:
    case CPP_MACRO_ARG:
    case CPP_PLACEMARKER:
      abort ();

    default: break;
    }

  return type;
  
#else
  int c;
  char *p;
  int wide_flag = 0;
  int objc_flag = 0;
  int charconst = 0;

  *value = NULL_TREE;

 retry:
  c = getch ();

  /* Effectively do c = skip_white_space (c)
     but do it faster in the usual cases.  */
  while (1)
    switch (c)
      {
      case ' ':
      case '\t':
      case '\f':
      case '\v':
          c = getch ();
        break;

      case '\n':
        c = skip_white_space (c);
      default:
        goto found_nonwhite;
      }
 found_nonwhite:

  lineno = lex_lineno;

  switch (c)
    {
    case EOF:
      return CPP_EOF;

    case 'L':
      /* Capital L may start a wide-string or wide-character constant.  */
      {
        register int c1 = getch();
        if (c1 == '\'')
          {
            wide_flag = 1;
            goto char_constant;
          }
        if (c1 == '"')
          {
            wide_flag = 1;
            goto string_constant;
          }
        put_back (c1);
      }
      goto letter;

    case '@':
      if (!doing_objc_thang)
        goto straychar;
      else
        {
          /* '@' may start a constant string object.  */
          register int c1 = getch ();
          if (c1 == '"')
            {
              objc_flag = 1;
              goto string_constant;
            }
          put_back (c1);
          /* Fall through to treat '@' as the start of an identifier.  */
        }

    case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
    case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
    case 'K':             case 'M':  case 'N':  case 'O':
    case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
    case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
    case 'Z':
    case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
    case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
    case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
    case 'p':  case 'q':  case 'r':  case 's':  case 't':
    case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
    case 'z':
    case '_':
    case '$':
    letter:
      p = token_buffer;
      while (ISALNUM (c) || c == '_' || c == '$' || c == '@')
        {
          /* Make sure this char really belongs in an identifier.  */
          if (c == '$')
            {
              if (! dollars_in_ident)
                error ("'$' in identifier");
              else if (pedantic)
                pedwarn ("'$' in identifier");
            }

          if (p >= token_buffer + maxtoken)
            p = extend_token_buffer (p);

          *p++ = c;
          c = getch();
        }

      put_back (c);

      if (p >= token_buffer + maxtoken)
        p = extend_token_buffer (p);
      *p = 0;

      *value = get_identifier (token_buffer);
      return CPP_NAME;

    case '.':
        {
          /* It's hard to preserve tokenization on '.' because
             it could be a symbol by itself, or it could be the
             start of a floating point number and cpp won't tell us.  */
          int c1 = getch ();
          if (c1 == '.')
            {
              int c2 = getch ();
              if (c2 == '.')
                return CPP_ELLIPSIS;

              put_back (c2);
              error ("parse error at '..'");
            }
          else if (c1 == '*' && c_language == clk_cplusplus)
            return CPP_DOT_STAR;

          put_back (c1);
          if (ISDIGIT (c1))
            goto number;
        }
        return CPP_DOT;

    case '0':  case '1':  case '2':  case '3':  case '4':
    case '5':  case '6':  case '7':  case '8':  case '9':
    number:
      p = token_buffer;
      /* Scan the next preprocessing number.  All C numeric constants
         are preprocessing numbers, but not all preprocessing numbers
         are valid numeric constants.  Preprocessing numbers fit the
         regular expression \.?[0-9]([0-9a-zA-Z_.]|[eEpP][+-])*
         See C99 section 6.4.8. */
      for (;;)
        {
          if (p >= token_buffer + maxtoken)
            p = extend_token_buffer (p);

          *p++ = c;
          c = getch();

          if (c == '+' || c == '-')
            {
              int d = p[-1];
              if (d == 'e' || d == 'E' || d == 'p' || d == 'P')
                continue;
            }
          if (ISALNUM (c) || c == '_' || c == '.')
            continue;
          break;
        }
      put_back (c);

      *value = lex_number (token_buffer, p - token_buffer);
      return CPP_NUMBER;

    case '\'':
    char_constant:
    charconst = 1;

    case '"':
    string_constant:
      {
        int delimiter = charconst ? '\'' : '"';
#ifdef MULTIBYTE_CHARS
        int longest_char = local_mb_cur_max ();
        (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
#endif
        c = getch ();
        p = token_buffer + 1;

        while (c != delimiter && c != EOF)
          {
            if (p + 2 > token_buffer + maxtoken)
              p = extend_token_buffer (p);

            /* ignore_escape_flag is set for reading the filename in #line.  */
            if (!ignore_escape_flag && c == '\\')
              {
                *p++ = c;
                *p++ = getch ();  /* escaped character */
                c = getch ();
                continue;
              }
            else
              {
#ifdef MULTIBYTE_CHARS
                int i;
                int char_len = -1;
                for (i = 0; i < longest_char; ++i)
                  {
                    if (p + i >= token_buffer + maxtoken)
                      p = extend_token_buffer (p);
                    p[i] = c;

                    char_len = local_mblen (p, i + 1);
                    if (char_len != -1)
                      break;
                    c = getch ();
                  }
                if (char_len == -1)
                  {
                    /* Replace all except the first byte.  */
                    put_back (c);
                    for (--i; i > 0; --i)
                      put_back (p[i]);
                    char_len = 1;
                  }
                /* mbtowc sometimes needs an extra char before accepting */
                else if (char_len <= i)
                  put_back (c);

                p += char_len;
#else
                *p++ = c;
#endif
                c = getch ();
              }
          }
      }

      if (charconst)
        {
          *value =  lex_charconst (token_buffer + 1, p - (token_buffer + 1),
                                   wide_flag);
          return wide_flag ? CPP_WCHAR : CPP_CHAR;
        }
      else
        {
          *value = lex_string (token_buffer + 1, p - (token_buffer + 1),
                               wide_flag);
          return wide_flag ? CPP_WSTRING : objc_flag ? CPP_OSTRING : CPP_STRING;
        }

    case '+':
    case '-':
    case '&':
    case '|':
    case ':':
    case '<':
    case '>':
    case '*':
    case '/':
    case '%':
    case '^':
    case '!':
    case '=':
      {
        int c1;
        enum cpp_ttype type = CPP_EOF;

        switch (c)
          {
          case '+': type = CPP_PLUS;    break;
          case '-': type = CPP_MINUS;   break;
          case '&': type = CPP_AND;     break;
          case '|': type = CPP_OR;      break;
          case ':': type = CPP_COLON;   break;
          case '<': type = CPP_LESS;    break;
          case '>': type = CPP_GREATER; break;
          case '*': type = CPP_MULT;    break;
          case '/': type = CPP_DIV;     break;
          case '%': type = CPP_MOD;     break;
          case '^': type = CPP_XOR;     break;
          case '!': type = CPP_NOT;     break;
          case '=': type = CPP_EQ;      break;
          }

        c1 = getch ();

        if (c1 == '=' && type < CPP_LAST_EQ)
          return type + (CPP_EQ_EQ - CPP_EQ);
        else if (c == c1)
          switch (c)
            {
            case '+':   return CPP_PLUS_PLUS;
            case '-':   return CPP_MINUS_MINUS;
            case '&':   return CPP_AND_AND;
            case '|':   return CPP_OR_OR;
            case ':':
              if (c_language == clk_cplusplus)
                return CPP_SCOPE;
              break;

            case '<':   type = CPP_LSHIFT;      goto do_triad;
            case '>':   type = CPP_RSHIFT;      goto do_triad;
            }
        else
          switch (c)
            {
            case '-':
              if (c1 == '>')
                {
                  if (c_language == clk_cplusplus)
                    {
                      c1 = getch ();
                      if (c1 == '*')
                        return CPP_DEREF_STAR;
                      put_back (c1);
                    }
                  return CPP_DEREF;
                }
              break;

            case '>':
              if (c1 == '?' && c_language == clk_cplusplus)
                { type = CPP_MAX; goto do_triad; }
              break;

            case '<':
              if (c1 == ':' && flag_digraphs)
                return CPP_OPEN_SQUARE;
              if (c1 == '%' && flag_digraphs)
                { indent_level++; return CPP_OPEN_BRACE; }
              if (c1 == '?' && c_language == clk_cplusplus)
                { type = CPP_MIN; goto do_triad; }
              break;

            case ':':
              if (c1 == '>' && flag_digraphs)
                return CPP_CLOSE_SQUARE;
              break;
            case '%':
              if (c1 == '>' && flag_digraphs)
                { indent_level--; return CPP_CLOSE_BRACE; }
              break;
            }

        put_back (c1);
        return type;

      do_triad:
        c1 = getch ();
        if (c1 == '=')
          type += (CPP_EQ_EQ - CPP_EQ);
        else
          put_back (c1);
        return type;
      }

    case '~':                   return CPP_COMPL;
    case '?':                   return CPP_QUERY;
    case ',':                   return CPP_COMMA;
    case '(':                   return CPP_OPEN_PAREN;
    case ')':                   return CPP_CLOSE_PAREN;
    case '[':                   return CPP_OPEN_SQUARE;
    case ']':                   return CPP_CLOSE_SQUARE;
    case '{': indent_level++;   return CPP_OPEN_BRACE;
    case '}': indent_level--;   return CPP_CLOSE_BRACE;
    case ';':                   return CPP_SEMICOLON;

    straychar:
    default:
      if (ISGRAPH (c))
        error ("stray '%c' in program", c);
      else
        error ("stray '\\%#o' in program", c);
      goto retry;
    }
  /* NOTREACHED */
#endif
}


#define ERROR(msgid) do { error(msgid); goto syntax_error; } while(0)

static tree
lex_number (str, len)
     const char *str;
     unsigned int len;
{
  int base = 10;
  int count = 0;
  int largest_digit = 0;
  int numdigits = 0;
  int overflow = 0;
  int c;
  tree value;
  const char *p;
  enum anon1 { NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON } floatflag = NOT_FLOAT;
  
  /* We actually store only HOST_BITS_PER_CHAR bits in each part.
     The code below which fills the parts array assumes that a host
     int is at least twice as wide as a host char, and that 
     HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
     Two HOST_WIDE_INTs is the largest int literal we can store.
     In order to detect overflow below, the number of parts (TOTAL_PARTS)
     must be exactly the number of parts needed to hold the bits
     of two HOST_WIDE_INTs. */
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
  unsigned int parts[TOTAL_PARTS];
  
  /* Optimize for most frequent case.  */
  if (len == 1)
    {
      if (*str == '0')
        return integer_zero_node;
      else if (*str == '1')
        return integer_one_node;
      else
        return build_int_2 (*str - '0', 0);
    }

  for (count = 0; count < TOTAL_PARTS; count++)
    parts[count] = 0;

  /* len is known to be >1 at this point.  */
  p = str;

  if (len > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
    {
      base = 16;
      p = str + 2;
    }
  /* The ISDIGIT check is so we are not confused by a suffix on 0.  */
  else if (str[0] == '0' && ISDIGIT (str[1]))
    {
      base = 8;
      p = str + 1;
    }

  do
    {
      c = *p++;

      if (c == '.')
        {
          if (base == 16 && pedantic && !flag_isoc99)
            pedwarn ("floating constant may not be in radix 16");
          else if (floatflag == AFTER_POINT)
            ERROR ("too many decimal points in floating constant");
          else if (floatflag == AFTER_EXPON)
            ERROR ("decimal point in exponent - impossible!");
          else
            floatflag = AFTER_POINT;

          if (base == 8)
            base = 10;
        }
      else if (c == '_')
        /* Possible future extension: silently ignore _ in numbers,
           permitting cosmetic grouping - e.g. 0x8000_0000 == 0x80000000
           but somewhat easier to read.  Ada has this?  */
        ERROR ("underscore in number");
      else
        {
          int n;
          /* It is not a decimal point.
             It should be a digit (perhaps a hex digit).  */

          if (ISDIGIT (c))
            {
              n = c - '0';
            }
          else if (base <= 10 && (c == 'e' || c == 'E'))
            {
              base = 10;
              floatflag = AFTER_EXPON;
              break;
            }
          else if (base == 16 && (c == 'p' || c == 'P'))
            {
              floatflag = AFTER_EXPON;
              break;   /* start of exponent */
            }
          else if (base == 16 && c >= 'a' && c <= 'f')
            {
              n = c - 'a' + 10;
            }
          else if (base == 16 && c >= 'A' && c <= 'F')
            {
              n = c - 'A' + 10;
            }
          else
            {
              p--;
              break;  /* start of suffix */
            }

          if (n >= largest_digit)
            largest_digit = n;
          numdigits++;

          for (count = 0; count < TOTAL_PARTS; count++)
            {
              parts[count] *= base;
              if (count)
                {
                  parts[count]
                    += (parts[count-1] >> HOST_BITS_PER_CHAR);
                  parts[count-1]
                    &= (1 << HOST_BITS_PER_CHAR) - 1;
                }
              else
                parts[0] += n;
            }

          /* If the highest-order part overflows (gets larger than
             a host char will hold) then the whole number has 
             overflowed.  Record this and truncate the highest-order
             part. */
          if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
            {
              overflow = 1;
              parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
            }
        }
    }
  while (p < str + len);

  /* This can happen on input like `int i = 0x;' */
  if (numdigits == 0)
    ERROR ("numeric constant with no digits");

  if (largest_digit >= base)
    ERROR ("numeric constant contains digits beyond the radix");

  if (floatflag != NOT_FLOAT)
    {
      tree type;
      int imag, fflag, lflag, conversion_errno;
      REAL_VALUE_TYPE real;
      struct pf_args args;
      char *copy;

      if (base == 16 && floatflag != AFTER_EXPON)
        ERROR ("hexadecimal floating constant has no exponent");

      /* Read explicit exponent if any, and put it in tokenbuf.  */
      if ((base == 10 && ((c == 'e') || (c == 'E')))
          || (base == 16 && (c == 'p' || c == 'P')))
        {
          if (p < str + len)
            c = *p++;
          if (p < str + len && (c == '+' || c == '-'))
            c = *p++;
          /* Exponent is decimal, even if string is a hex float.  */
          if (! ISDIGIT (c))
            ERROR ("floating constant exponent has no digits");
          while (p < str + len && ISDIGIT (c))
            c = *p++;
          if (! ISDIGIT (c))
            p--;
        }

      /* Copy the float constant now; we don't want any suffixes in the
         string passed to parse_float.  */
      copy = alloca (p - str + 1);
      memcpy (copy, str, p - str);
      copy[p - str] = '\0';

      /* Now parse suffixes.  */
      fflag = lflag = imag = 0;
      while (p < str + len)
        switch (*p++)
          {
          case 'f': case 'F':
            if (fflag)
              ERROR ("more than one 'f' suffix on floating constant");
            else if (warn_traditional && !in_system_header)
              warning ("traditional C rejects the 'f' suffix");

            fflag = 1;
            break;

          case 'l': case 'L':
            if (lflag)
              ERROR ("more than one 'l' suffix on floating constant");
            else if (warn_traditional && !in_system_header)
              warning ("traditional C rejects the 'l' suffix");

            lflag = 1;
            break;

          case 'i': case 'I':
          case 'j': case 'J':
            if (imag)
              ERROR ("more than one 'i' or 'j' suffix on floating constant");
            else if (pedantic)
              pedwarn ("ISO C forbids imaginary numeric constants");
            imag = 1;
            break;

          default:
            ERROR ("invalid suffix on floating constant");
          }

      /* Setup input for parse_float() */
      args.str = copy;
      args.fflag = fflag;
      args.lflag = lflag;
      args.base = base;

      /* Convert string to a double, checking for overflow.  */
      if (do_float_handler (parse_float, (PTR) &args))
        {
          /* Receive output from parse_float() */
          real = args.value;
        }
      else
          /* We got an exception from parse_float() */
          ERROR ("floating constant out of range");

      /* Receive output from parse_float() */
      conversion_errno = args.conversion_errno;
      type = args.type;
            
#ifdef ERANGE
      /* ERANGE is also reported for underflow,
         so test the value to distinguish overflow from that.  */
      if (conversion_errno == ERANGE && !flag_traditional && pedantic
          && (REAL_VALUES_LESS (dconst1, real)
              || REAL_VALUES_LESS (real, dconstm1)))
        warning ("floating point number exceeds range of 'double'");
#endif

      /* Create a node with determined type and value.  */
      if (imag)
        value = build_complex (NULL_TREE, convert (type, integer_zero_node),
                               build_real (type, real));
      else
        value = build_real (type, real);
    }
  else
    {
      tree trad_type, ansi_type, type;
      HOST_WIDE_INT high, low;
      int spec_unsigned = 0;
      int spec_long = 0;
      int spec_long_long = 0;
      int spec_imag = 0;
      int suffix_lu = 0;
      int warn = 0, i;

      trad_type = ansi_type = type = NULL_TREE;
      while (p < str + len)
        {
          c = *p++;
          switch (c)
            {
            case 'u': case 'U':
              if (spec_unsigned)
                error ("two 'u' suffixes on integer constant");
              else if (warn_traditional && !in_system_header)
                warning ("traditional C rejects the 'u' suffix");

              spec_unsigned = 1;
              if (spec_long)
                suffix_lu = 1;
              break;

            case 'l': case 'L':
              if (spec_long)
                {
                  if (spec_long_long)
                    error ("three 'l' suffixes on integer constant");
                  else if (suffix_lu)
                    error ("'lul' is not a valid integer suffix");
                  else if (c != spec_long)
                    error ("'Ll' and 'lL' are not valid integer suffixes");
                  else if (pedantic && ! flag_isoc99
                           && ! in_system_header && warn_long_long)
                    pedwarn ("ISO C89 forbids long long integer constants");
                  spec_long_long = 1;
                }
              spec_long = c;
              break;

            case 'i': case 'I': case 'j': case 'J':
              if (spec_imag)
                error ("more than one 'i' or 'j' suffix on integer constant");
              else if (pedantic)
                pedwarn ("ISO C forbids imaginary numeric constants");
              spec_imag = 1;
              break;

            default:
              ERROR ("invalid suffix on integer constant");
            }
        }

      /* If the literal overflowed, pedwarn about it now. */
      if (overflow)
        {
          warn = 1;
          pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
        }

      /* This is simplified by the fact that our constant
         is always positive.  */

      high = low = 0;

      for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
        {
          high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
                                              / HOST_BITS_PER_CHAR)]
                   << (i * HOST_BITS_PER_CHAR));
          low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
        }

      value = build_int_2 (low, high);
      TREE_TYPE (value) = long_long_unsigned_type_node;

      /* If warn_traditional, calculate both the ISO type and the
         traditional type, then see if they disagree.
         Otherwise, calculate only the type for the dialect in use.  */
      if (warn_traditional || flag_traditional)
        {
          /* Calculate the traditional type.  */
          /* Traditionally, any constant is signed; but if unsigned is
             specified explicitly, obey that.  Use the smallest size
             with the right number of bits, except for one special
             case with decimal constants.  */
          if (! spec_long && base != 10
              && int_fits_type_p (value, unsigned_type_node))
            trad_type = spec_unsigned ? unsigned_type_node : integer_type_node;
          /* A decimal constant must be long if it does not fit in
             type int.  I think this is independent of whether the
             constant is signed.  */
          else if (! spec_long && base == 10
                   && int_fits_type_p (value, integer_type_node))
            trad_type = spec_unsigned ? unsigned_type_node : integer_type_node;
          else if (! spec_long_long)
            trad_type = (spec_unsigned
                         ? long_unsigned_type_node
                         : long_integer_type_node);
          else if (int_fits_type_p (value,
                                    spec_unsigned 
                                    ? long_long_unsigned_type_node
                                    : long_long_integer_type_node)) 
            trad_type = (spec_unsigned
                         ? long_long_unsigned_type_node
                         : long_long_integer_type_node);
          else
            trad_type = (spec_unsigned
                         ? widest_unsigned_literal_type_node
                         : widest_integer_literal_type_node);
        }
      if (warn_traditional || ! flag_traditional)
        {
          /* Calculate the ISO type.  */
          if (! spec_long && ! spec_unsigned
              && int_fits_type_p (value, integer_type_node))
            ansi_type = integer_type_node;
          else if (! spec_long && (base != 10 || spec_unsigned)
                   && int_fits_type_p (value, unsigned_type_node))
            ansi_type = unsigned_type_node;
          else if (! spec_unsigned && !spec_long_long
                   && int_fits_type_p (value, long_integer_type_node))
            ansi_type = long_integer_type_node;
          else if (! spec_long_long
                   && int_fits_type_p (value, long_unsigned_type_node))
            ansi_type = long_unsigned_type_node;
          else if (! spec_unsigned
                   && int_fits_type_p (value, long_long_integer_type_node))
            ansi_type = long_long_integer_type_node;
          else if (int_fits_type_p (value, long_long_unsigned_type_node))
            ansi_type = long_long_unsigned_type_node;
          else if (! spec_unsigned
                   && int_fits_type_p (value, widest_integer_literal_type_node))
            ansi_type = widest_integer_literal_type_node;
          else
            ansi_type = widest_unsigned_literal_type_node;
        }

      type = flag_traditional ? trad_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 && !in_system_header
          && base == 10 && trad_type != ansi_type)
        {
          if (TYPE_PRECISION (trad_type) != TYPE_PRECISION (ansi_type))
            warning ("width of integer constant changes with -traditional");
          else if (TREE_UNSIGNED (trad_type) != TREE_UNSIGNED (ansi_type))
            warning ("integer constant is unsigned in ISO C, signed with -traditional");
          else
            warning ("width of integer constant may change on other systems with -traditional");
        }

      if (pedantic && !flag_traditional && !spec_long_long && !warn
          && (TYPE_PRECISION (long_integer_type_node) < TYPE_PRECISION (type)))
        {
          warn = 1;
          pedwarn ("integer constant larger than the maximum value of an unsigned long int");
        }

      if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
        warning ("decimal constant is so large that it is unsigned");

      if (spec_imag)
        {
          if (TYPE_PRECISION (type)
              <= TYPE_PRECISION (integer_type_node))
            value = build_complex (NULL_TREE, integer_zero_node,
                                   convert (integer_type_node, value));
          else
            ERROR ("complex integer constant is too wide for 'complex int'");
        }
      else if (flag_traditional && !int_fits_type_p (value, type))
        /* The traditional constant 0x80000000 is signed
           but doesn't fit in the range of int.
           This will change it to -0x80000000, which does fit.  */
        {
          TREE_TYPE (value) = unsigned_type (type);
          value = convert (type, value);
          TREE_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (value) = 0;
        }
      else
        TREE_TYPE (value) = type;

      /* If it's still an integer (not a complex), and it doesn't
         fit in the type we choose for it, then pedwarn. */

      if (! warn
          && TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
          && ! int_fits_type_p (value, TREE_TYPE (value)))
        pedwarn ("integer constant is larger than the maximum value for its type");
    }

  if (p < str + len)
    error ("missing white space after number '%.*s'", (int) (p - str), str);

  return value;

 syntax_error:
  return integer_zero_node;
}

static tree
lex_string (str, len, wide)
     const char *str;
     unsigned int len;
     int wide;
{
  tree value;
  char *buf = alloca ((len + 1) * (wide ? WCHAR_BYTES : 1));
  char *q = buf;
  const char *p = str, *limit = str + len;
  unsigned int c;
  unsigned width = wide ? WCHAR_TYPE_SIZE
                        : TYPE_PRECISION (char_type_node);

#ifdef MULTIBYTE_CHARS
  /* Reset multibyte conversion state.  */
  (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
#endif

  while (p < limit)
    {
#ifdef MULTIBYTE_CHARS
      wchar_t wc;
      int char_len;

      char_len = local_mbtowc (&wc, p, limit - p);
      if (char_len == -1)
        {
          warning ("Ignoring invalid multibyte character");
          char_len = 1;
          c = *p++;
        }
      else
        {
          p += char_len;
          c = wc;
        }
#else
      c = *p++;
#endif

      if (c == '\\' && !ignore_escape_flag)
        {
          p = readescape (p, limit, &c);
          if (width < HOST_BITS_PER_INT
              && (unsigned) c >= ((unsigned)1 << width))
            pedwarn ("escape sequence out of range for character");
        }
        
      /* Add this single character into the buffer either as a wchar_t
         or as a single byte.  */
      if (wide)
        {
          unsigned charwidth = TYPE_PRECISION (char_type_node);
          unsigned bytemask = (1 << width) - 1;
          int byte;

          for (byte = 0; byte < WCHAR_BYTES; ++byte)
            {
              int n;
              if (byte >= (int) sizeof (c))
                n = 0;
              else
                n = (c >> (byte * charwidth)) & bytemask;
              if (BYTES_BIG_ENDIAN)
                q[WCHAR_BYTES - byte - 1] = n;
              else
                q[byte] = n;
            }
          q += WCHAR_BYTES;
        }
      else
        {
          *q++ = c;
        }
    }

  /* Terminate the string value, either with a single byte zero
     or with a wide zero.  */

  if (wide)
    {
      memset (q, 0, WCHAR_BYTES);
      q += WCHAR_BYTES;
    }
  else
    {
      *q++ = '\0';
    }

  value = build_string (q - buf, buf);

  if (wide)
    TREE_TYPE (value) = wchar_array_type_node;
  else
    TREE_TYPE (value) = char_array_type_node;
  return value;
}

static tree
lex_charconst (str, len, wide)
     const char *str;
     unsigned int len;
     int wide;
{
  const char *limit = str + len;
  int result = 0;
  int num_chars = 0;
  int chars_seen = 0;
  unsigned width = TYPE_PRECISION (char_type_node);
  int max_chars;
  unsigned int c;
  tree value;

#ifdef MULTIBYTE_CHARS
  int longest_char = local_mb_cur_max ();
  (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
#endif

  max_chars = TYPE_PRECISION (integer_type_node) / width;
  if (wide)
    width = WCHAR_TYPE_SIZE;

  while (str < limit)
    {
#ifdef MULTIBYTE_CHARS
      wchar_t wc;
      int char_len;

      char_len = local_mbtowc (&wc, str, limit - str);
      if (char_len == -1)
        {
          warning ("Ignoring invalid multibyte character");
          char_len = 1;
          c = *str++;
        }
      else
        {
          p += char_len;
          c = wc;
        }
#else
      c = *str++;
#endif

      ++chars_seen;
      if (c == '\\')
        {
          str = readescape (str, limit, &c);
          if (width < HOST_BITS_PER_INT
              && (unsigned) c >= ((unsigned)1 << width))
            pedwarn ("escape sequence out of range for character");
        }
#ifdef MAP_CHARACTER
      if (ISPRINT (c))
        c = MAP_CHARACTER (c);
#endif
      
      /* Merge character into result; ignore excess chars.  */
      num_chars += (width / TYPE_PRECISION (char_type_node));
      if (num_chars < max_chars + 1)
        {
          if (width < HOST_BITS_PER_INT)
            result = (result << width) | (c & ((1 << width) - 1));
          else
            result = c;
        }
    }

  if (chars_seen == 0)
    error ("empty character constant");
  else if (num_chars > max_chars)
    {
      num_chars = max_chars;
      error ("character constant too long");
    }
  else if (chars_seen != 1 && ! flag_traditional && warn_multichar)
    warning ("multi-character character constant");

  /* If char type is signed, sign-extend the constant.  */
  if (! wide)
    {
      int num_bits = num_chars * width;
      if (num_bits == 0)
        /* We already got an error; avoid invalid shift.  */
        value = build_int_2 (0, 0);
      else if (TREE_UNSIGNED (char_type_node)
               || ((result >> (num_bits - 1)) & 1) == 0)
        value = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
                                       >> (HOST_BITS_PER_WIDE_INT - num_bits)),
                             0);
      else
        value = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
                                        >> (HOST_BITS_PER_WIDE_INT - num_bits)),
                             -1);
      /* In C, a character constant has type 'int'; in C++, 'char'.  */
      if (chars_seen <= 1 && c_language == clk_cplusplus)
        TREE_TYPE (value) = char_type_node;
      else
        TREE_TYPE (value) = integer_type_node;
    }
  else
    {
      value = build_int_2 (result, 0);
      TREE_TYPE (value) = wchar_type_node;
    }

  return value;
}