* df-scan.c (df_collection_rec): Adjust.

[official-gcc.git] / gcc / gengtype-state.c

/* Gengtype persistent state serialization & de-serialization.
   Useful for gengtype in plugin mode.

   Copyright (C) 2010-2013 Free Software Foundation, Inc.

   This file is part of GCC.

   GCC 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 3, or (at your option) any later
   version.

   GCC 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 GCC; see the file COPYING3.  If not see
   <http://www.gnu.org/licenses/>.

   Contributed by Jeremie Salvucci <jeremie.salvucci@free.fr>
   and Basile Starynkevitch <basile@starynkevitch.net>
*/

#ifdef GENERATOR_FILE
#include "bconfig.h"
#else
#include "config.h"
#endif
#include "system.h"
#include "errors.h"     /* For fatal.  */
#include "double-int.h"
#include "hashtab.h"
#include "version.h"    /* For version_string & pkgversion_string.  */
#include "obstack.h"
#include "gengtype.h"



/* Gives the file location of a type, if any.  */
static inline struct fileloc*
type_lineloc (const_type_p ty)
{
  if (!ty)
    return NULL;
  switch (ty->kind)
    {
    case TYPE_NONE:
      gcc_unreachable ();
    case TYPE_STRUCT:
    case TYPE_UNION:
    case TYPE_LANG_STRUCT:
    case TYPE_USER_STRUCT:
    case TYPE_UNDEFINED:
      return CONST_CAST (struct fileloc*, &ty->u.s.line);
    case TYPE_PARAM_STRUCT:
      return CONST_CAST (struct fileloc*, &ty->u.param_struct.line);
    case TYPE_SCALAR:
    case TYPE_STRING:
    case TYPE_POINTER:
    case TYPE_ARRAY:
      return NULL;
    default:
      gcc_unreachable ();
    }
}

/* The state file has simplistic lispy lexical tokens.  Its lexer gives
   a linked list of struct state_token_st, through the peek_state_token
   function.  Lexical tokens are consumed with next_state_tokens.  */


/* The lexical kind of each lispy token.  */
enum state_token_en
{
  STOK_NONE,                    /* Never used.  */
  STOK_INTEGER,                 /* Integer token.  */
  STOK_STRING,                  /* String token.  */
  STOK_LEFTPAR,                 /* Left opening parenthesis.  */
  STOK_RIGHTPAR,                /* Right closing parenthesis.  */
  STOK_NAME                     /* hash-consed name or identifier.  */
};


/* Structure and hash-table used to share identifiers or names.  */
struct state_ident_st
{
  /* TODO: We could improve the parser by reserving identifiers for
     state keywords and adding a keyword number for them.  That would
     mean adding another field in this state_ident_st struct.  */
  char stid_name[1];            /* actually bigger & null terminated */
};
static htab_t state_ident_tab;


/* The state_token_st structure is for lexical tokens in the read
   state file.  The stok_kind field discriminates the union.  Tokens
   are allocated by peek_state_token which calls read_a_state_token
   which allocate them.  Tokens are freed by calls to
   next_state_tokens.  Token are organized in a FIFO look-ahead queue
   filled by peek_state_token.  */
struct state_token_st
{
  enum state_token_en stok_kind;        /* the lexical kind
                                           discriminates the stok_un
                                           union  */
  int stok_line;                        /* the line number */
  int stok_col;                         /* the column number */
  const char *stok_file;                /* the file path */
  struct state_token_st *stok_next;     /* the next token in the
                                           queue, when peeked */
  union                                 /* discriminated by stok_kind! */
  {
    int stok_num;                       /* when STOK_INTEGER */
    char stok_string[1];                /* when STOK_STRING, actual size is
                                           bigger and null terminated */
    struct state_ident_st *stok_ident;  /* when STOK_IDENT */
    void *stok_ptr;                     /* null otherwise */
  }
  stok_un;
};




#define NULL_STATE_TOKEN (struct state_token_st*)0

/* the state_token pointer contains the leftmost current token.  The
   tokens are organized in a linked queue, using stok_next, for token
   look-ahead.  */
struct state_token_st *state_token = NULL_STATE_TOKEN;

/* Used by the reading lexer.  */
static FILE *state_file;
static const char *state_path = NULL;
static int state_line = 0;
static long state_bol = 0;      /* offset of beginning of line */

/* A class for writing out s-expressions, keeping track of newlines and
   nested indentation.  */
class s_expr_writer
{
public:
  s_expr_writer ();

  void write_new_line ();
  void write_any_indent (int leading_spaces);

  void begin_s_expr (const char *tag);
  void end_s_expr ();

private:
  int m_indent_amount;
  int m_had_recent_newline;
}; // class s_expr_writer

/* A class for writing out "gtype.state".  */
class state_writer : public s_expr_writer
{
public:
  state_writer ();

private:
  void write_state_fileloc (struct fileloc *floc);
  void write_state_fields (pair_p fields);
  void write_state_a_string (const char *s);
  void write_state_string_option (options_p current);
  void write_state_type_option (options_p current);
  void write_state_nested_option (options_p current);
  void write_state_option (options_p current);
  void write_state_options (options_p opt);
  void write_state_lang_bitmap (lang_bitmap bitmap);
  void write_state_version (const char *version);
  void write_state_scalar_type (type_p current);
  void write_state_string_type (type_p current);
  void write_state_undefined_type (type_p current);
  void write_state_struct_union_type (type_p current, const char *kindstr);
  void write_state_struct_type (type_p current);
  void write_state_user_struct_type (type_p current);
  void write_state_union_type (type_p current);
  void write_state_lang_struct_type (type_p current);
  void write_state_param_struct_type (type_p current);
  void write_state_pointer_type (type_p current);
  void write_state_array_type (type_p current);
  void write_state_gc_used (enum gc_used_enum gus);
  void write_state_common_type_content (type_p current);
  void write_state_type (type_p current);
  void write_state_pair (pair_p current);
  int write_state_pair_list (pair_p list);
  void write_state_typedefs (void);
  void write_state_structures (void);
  void write_state_param_structs (void);
  void write_state_variables (void);
  void write_state_srcdir (void);
  void write_state_files_list (void);
  void write_state_languages (void);

  friend void write_state (const char *state_path);

private:
  /* Counter of written types.  */
  int m_state_written_type_count;
}; // class state_writer


/* class s_expr_writer's trivial constructor.  */
s_expr_writer::s_expr_writer ()
  : m_indent_amount (0),
    m_had_recent_newline (0)
{
}

/* Write a newline to the output file, merging adjacent newlines.  */
void
s_expr_writer::write_new_line (void)
{
  /* Don't add a newline if we've just had one.  */
  if (!m_had_recent_newline)
    {
      fprintf (state_file, "\n");
      m_had_recent_newline = 1;
    }
}

/* If we've just had a newline, write the indentation amount, potentially
   omitting some spaces.

   LEADING_SPACES exists to support code that writes strings with leading
   spaces (e.g " foo") which might occur within a line, or could be the first
   thing on a line.  By passing leading_spaces == 1, when such a string is the
   first thing on a line, write_any_indent () swallows the successive
   leading spaces into the indentation so that the "foo" begins at the expected
   column.  */
void
s_expr_writer::write_any_indent (int leading_spaces)
{
  int i;
  int amount = m_indent_amount - leading_spaces;
  if (m_had_recent_newline)
    for (i = 0; i < amount; i++)
      fprintf (state_file, " ");
  m_had_recent_newline = 0;
}

/* Write the beginning of a new s-expresion e.g. "(!foo "
   The writer automatically adds whitespace to show the hierarchical
   structure of the expressions, so each one starts on a new line,
   and any within it will be at an increased indentation level.  */
void
s_expr_writer::begin_s_expr (const char *tag)
{
  write_new_line ();
  write_any_indent (0);
  fprintf (state_file, "(!%s ", tag);
  m_indent_amount++;
}

/* Write out the end of an s-expression: any necssessary indentation,
   a closing parenthesis, and a new line.  */
void
s_expr_writer::end_s_expr (void)
{
  m_indent_amount--;
  write_any_indent (0);
  fprintf (state_file, ")");
  write_new_line ();
}


/* class state_writer's trivial constructor.  */
state_writer::state_writer ()
  : s_expr_writer (),
    m_state_written_type_count (0)
{
}


/* Fatal error messages when reading the state.  They are extremely
   unlikely, and only appear when this gengtype-state.c file is buggy,
   or when reading a gengtype state which was not generated by the
   same version of gengtype or GCC.  */


/* Fatal message while reading state.  */
static inline void 
fatal_reading_state (struct state_token_st* tok, const char*msg)
{
  if (tok)
    fatal ("%s:%d:%d: Invalid state file; %s",
           tok->stok_file, tok->stok_line, tok->stok_col, 
           msg); 
  else
    fatal ("%s:%d: Invalid state file; %s", 
           state_path, state_line, msg);
}


/* Fatal printf-like message while reading state.  This can't be a
   function, because there is no way to pass a va_arg to a variant of
   fatal.  */
#define fatal_reading_state_printf(Tok,Fmt,...) do {    \
    struct state_token_st* badtok = Tok;                \
    if (badtok)                                         \
      fatal ("%s:%d:%d: Invalid state file; " Fmt,      \
              badtok->stok_file,                        \
              badtok->stok_line,                        \
              badtok->stok_col, __VA_ARGS__);           \
    else                                                \
      fatal ("%s:%d: Invalid state file; " Fmt,         \
             state_path, state_line, __VA_ARGS__);      \
  } while (0)


/* Find or allocate an identifier in our name hash table.  */
static struct state_ident_st *
state_ident_by_name (const char *name, enum insert_option optins)
{
  PTR *slot = NULL;
  int namlen = 0;
  struct state_ident_st *stid = NULL;

  if (!name || !name[0])
    return NULL;

  slot = htab_find_slot (state_ident_tab, name, optins);
  if (!slot)
    return NULL;

  namlen = strlen (name);
  stid =
    (struct state_ident_st *) xmalloc (sizeof (struct state_ident_st) +
                                       namlen);
  memset (stid, 0, sizeof (struct state_ident_st) + namlen);
  strcpy (stid->stid_name, name);
  *slot = stid;

  return stid;
}

/* Our token lexer is heavily inspired by MELT's lexer, and share some
   code with the file gcc/melt-runtime.c of the GCC MELT branch!  We
   really want the gengtype state to be easily parsable by MELT.  This
   is a usual lispy lexing routine, dealing with spaces and comments,
   numbers, parenthesis, names, strings.  */
static struct state_token_st *
read_a_state_token (void)
{
  int c = 0;
  long curoff = 0;
  struct state_token_st *tk = NULL;

 again: /* Read again, e.g. after a comment or spaces.  */
  c = getc (state_file);
  if (c == EOF)
    return NULL;

  /* Handle spaces, count lines.  */
  if (c == '\n')
    {
      state_line++;
      state_bol = curoff = ftell (state_file);
      goto again;
    };
  if (ISSPACE (c))
    goto again;
  /* Skip comments starting with semi-colon.  */
  if (c == ';')
    {   
      do
        {
          c = getc (state_file);
        }
      while (c > 0 && c != '\n');
      if (c == '\n')
        {
          state_line++;
          state_bol = curoff = ftell (state_file);
        }
      goto again;
    };
  /* Read signed numbers.  */
  if (ISDIGIT (c) || c == '-' || c == '+')
    {                           /* number */
      int n = 0;
      ungetc (c, state_file);
      curoff = ftell (state_file);
      if (fscanf (state_file, "%d", &n) <= 0)
        fatal_reading_state (NULL_STATE_TOKEN, "Lexical error in number");
      tk = XCNEW (struct state_token_st);
      tk->stok_kind = STOK_INTEGER;
      tk->stok_line = state_line;
      tk->stok_col = curoff - state_bol;
      tk->stok_file = state_path;
      tk->stok_next = NULL;
      tk->stok_un.stok_num = n;

      return tk;
    }
  /* Read an opening left parenthesis.  */
  else if (c == '(')
    {
      curoff = ftell (state_file);
      tk = XCNEW (struct state_token_st);
      tk->stok_kind = STOK_LEFTPAR;
      tk->stok_line = state_line;
      tk->stok_col = curoff - state_bol;
      tk->stok_file = state_path;
      tk->stok_next = NULL;

      return tk;
    }
  /* Read an closing right parenthesis.  */
  else if (c == ')')
    {
      curoff = ftell (state_file);
      tk = XCNEW (struct state_token_st);
      tk->stok_kind = STOK_RIGHTPAR;
      tk->stok_line = state_line;
      tk->stok_col = curoff - state_bol;
      tk->stok_file = state_path;
      tk->stok_next = NULL;

      return tk;
    }
  /* Read identifiers, using an obstack.  */
  else if (ISALPHA (c) || c == '_' || c == '$' || c == '!' || c == '#')
    {
      struct obstack id_obstack;
      struct state_ident_st *sid = NULL;
      char *ids = NULL;
      obstack_init (&id_obstack);
      curoff = ftell (state_file);
      while (ISALNUM (c) || c == '_' || c == '$' || c == '!' || c == '#')
        {
          obstack_1grow (&id_obstack, c);
          c = getc (state_file);
          if (c < 0)
            break;
        };
      if (c >= 0)
        ungetc (c, state_file);
      obstack_1grow (&id_obstack, (char) 0);
      ids = XOBFINISH (&id_obstack, char *);
      sid = state_ident_by_name (ids, INSERT);
      obstack_free (&id_obstack, NULL);
      ids = NULL;
      tk = XCNEW (struct state_token_st);
      tk->stok_kind = STOK_NAME;
      tk->stok_line = state_line;
      tk->stok_col = curoff - state_bol;
      tk->stok_file = state_path;
      tk->stok_next = NULL;
      tk->stok_un.stok_ident = sid;

      return tk;
    }
  /* Read a string, dealing with escape sequences a la C! */
  else if (c == '"')
    {
      char *cstr = NULL;
      int cslen = 0;
      struct obstack bstring_obstack;
      obstack_init (&bstring_obstack);
      curoff = ftell (state_file);
      while ((c = getc (state_file)) != '"' && c >= 0)
        {
          if (ISPRINT (c) && c != '\\')
            obstack_1grow (&bstring_obstack, (char) c);
          else if (ISSPACE (c) && c != '\n')
            obstack_1grow (&bstring_obstack, (char) c);
          else if (c == '\\')
            {
              c = getc (state_file);
              switch (c)
                {
                case 'a':
                  obstack_1grow (&bstring_obstack, '\a');
                  c = getc (state_file);
                  break;
                case 'b':
                  obstack_1grow (&bstring_obstack, '\b');
                  c = getc (state_file);
                  break;
                case 't':
                  obstack_1grow (&bstring_obstack, '\t');
                  c = getc (state_file);
                  break;
                case 'n':
                  obstack_1grow (&bstring_obstack, '\n');
                  c = getc (state_file);
                  break;
                case 'v':
                  obstack_1grow (&bstring_obstack, '\v');
                  c = getc (state_file);
                  break;
                case 'f':
                  obstack_1grow (&bstring_obstack, '\f');
                  c = getc (state_file);
                  break;
                case 'r':
                  obstack_1grow (&bstring_obstack, '\r');
                  c = getc (state_file);
                  break;
                case '"':
                  obstack_1grow (&bstring_obstack, '\"');
                  c = getc (state_file);
                  break;
                case '\\':
                  obstack_1grow (&bstring_obstack, '\\');
                  c = getc (state_file);
                  break;
                case ' ':
                  obstack_1grow (&bstring_obstack, ' ');
                  c = getc (state_file);
                  break;
                case 'x':
                  {
                    unsigned int cx = 0;
                    if (fscanf (state_file, "%02x", &cx) > 0 && cx > 0)
                      obstack_1grow (&bstring_obstack, cx);
                    else
                      fatal_reading_state
                        (NULL_STATE_TOKEN,
                         "Lexical error in string hex escape");
                    c = getc (state_file);
                    break;
                  }
                default:
                  fatal_reading_state
                    (NULL_STATE_TOKEN,
                     "Lexical error - unknown string escape");
                }
            }
          else
            fatal_reading_state (NULL_STATE_TOKEN, "Lexical error...");
        };
      if (c != '"')
        fatal_reading_state (NULL_STATE_TOKEN, "Unterminated string");
      obstack_1grow (&bstring_obstack, '\0');
      cstr = XOBFINISH (&bstring_obstack, char *);
      cslen = strlen (cstr);
      tk = (struct state_token_st *)
        xcalloc (sizeof (struct state_token_st) + cslen, 1);
      tk->stok_kind = STOK_STRING;
      tk->stok_line = state_line;
      tk->stok_col = curoff - state_bol;
      tk->stok_file = state_path;
      tk->stok_next = NULL;
      strcpy (tk->stok_un.stok_string, cstr);
      obstack_free (&bstring_obstack, NULL);

      return tk;
    }
  /* Got an unexpected character.  */
  fatal_reading_state_printf
    (NULL_STATE_TOKEN,
     "Lexical error at offset %ld - bad character \\%03o = '%c'",
     ftell (state_file), c, c);
}

/* Used for lexical look-ahead.  Retrieves the lexical token of rank
   DEPTH, starting with 0 when reading the state file.  Gives null on
   end of file.  */
static struct state_token_st *
peek_state_token (int depth)
{
  int remdepth = depth;
  struct state_token_st **ptoken = &state_token;
  struct state_token_st *tok = NULL;

  while (remdepth >= 0)
    {
      if (*ptoken == NULL)
        {
          *ptoken = tok = read_a_state_token ();
          if (tok == NULL)
            return NULL;
        }
      tok = *ptoken;
      ptoken = &((*ptoken)->stok_next);
      remdepth--;
    }

  return tok;
}

/* Consume the next DEPTH tokens and free them.  */
static void
next_state_tokens (int depth)
{
  struct state_token_st *n;

  while (depth > 0)
    {
      if (state_token != NULL)
        {
          n = state_token->stok_next;
          free (state_token);
          state_token = n;
        }
      else
        fatal_reading_state (NULL_STATE_TOKEN, "Tokens stack empty");

      depth--;
    }
}

/* Safely retrieve the lexical kind of a token.  */
static inline enum state_token_en
state_token_kind (struct state_token_st *p)
{
  if (p == NULL)
    return STOK_NONE;
  else
    return p->stok_kind;
}

/* Test if a token is a given name i.e. an identifier.  */
static inline bool
state_token_is_name (struct state_token_st *p, const char *name)
{
  if (p == NULL)
    return false;

  if (p->stok_kind != STOK_NAME)
    return false;

  return !strcmp (p->stok_un.stok_ident->stid_name, name);
}


/* Following routines are useful for serializing datas.
 *
 * We want to serialize :
 *          - typedefs list
 *          - structures list
 *          - param_structs list
 *          - variables list
 *
 * So, we have one routine for each kind of data.  The main writing
 * routine is write_state.  The main reading routine is
 * read_state.  Most writing routines write_state_FOO have a
 * corresponding reading routine read_state_FOO.  Reading is done in a
 * recursive descending way, and any read error is fatal.
 */

/* When reading the state, we need to remember the previously seen
   types by their state_number, since GTY-ed types are usually
   shared.  */
static htab_t state_seen_types;

/* Return the length of a linked list made of pairs.  */
static int pair_list_length (pair_p list);

/* Compute the length of a list of pairs, starting from the first
   one.  */
static int
pair_list_length (pair_p list)
{
  int nbpair = 0;
  pair_p l = NULL;
  for (l = list; l; l = l->next)
    nbpair++;
  return nbpair;
}

/* Write a file location.  Files relative to $(srcdir) are quite
   frequent and are handled specially.  This ensures that two gengtype
   state file-s produced by gengtype on the same GCC source tree are
   very similar and can be reasonably compared with diff, even if the
   two GCC source trees have different absolute paths.  */
void
state_writer::write_state_fileloc (struct fileloc *floc)
{

  if (floc != NULL && floc->line > 0)
    {
      const char *srcrelpath = NULL;
      gcc_assert (floc->file != NULL);
      /* Most of the files are inside $(srcdir) so it is worth to
         handle them specially.  */
      srcrelpath = get_file_srcdir_relative_path (floc->file);
      if (srcrelpath != NULL)
        {
          begin_s_expr ("srcfileloc");
          write_state_a_string (srcrelpath);
        }
      else
        {
          begin_s_expr ("fileloc");
          write_state_a_string (get_input_file_name (floc->file));
        }
      fprintf (state_file, " %d", floc->line);
      end_s_expr ();
    }
  else
    fprintf (state_file, "nil ");
}

/* Write a list of fields.  */
void
state_writer::write_state_fields (pair_p fields)
{
  int nbfields = pair_list_length (fields);
  int nbpairs = 0;
  begin_s_expr ("fields");
  fprintf (state_file, "%d ", nbfields);
  nbpairs = write_state_pair_list (fields);
  gcc_assert (nbpairs == nbfields);
  end_s_expr ();
}

/* Write a null-terminated string in our lexical convention, very
   similar to the convention of C.  */
void
state_writer::write_state_a_string (const char *s)
{
  char c;

  write_any_indent (1);

  fputs (" \"", state_file);
  for (; *s != 0; s++)
    {
      c = *s;
      switch (c)
        {
        case '\a':
          fputs ("\\a", state_file);
          break;
        case '\b':
          fputs ("\\b", state_file);
          break;
        case '\t':
          fputs ("\\t", state_file);
          break;
        case '\n':
          fputs ("\\n", state_file);
          break;
        case '\v':
          fputs ("\\v", state_file);
          break;
        case '\f':
          fputs ("\\f", state_file);
          break;
        case '\r':
          fputs ("\\r", state_file);
          break;
        case '\"':
          fputs ("\\\"", state_file);
          break;
        case '\\':
          fputs ("\\\\", state_file);
          break;
        default:
          if (ISPRINT (c))
            putc (c, state_file);
          else
            fprintf (state_file, "\\x%02x", (unsigned) c);
        }
    }
  fputs ("\"", state_file);
}

/* Our option-s have three kinds, each with its writer.  */
void
state_writer::write_state_string_option (options_p current)
{
  write_any_indent (0);
  fprintf (state_file, "string ");
  if (current->info.string != NULL)
    write_state_a_string (current->info.string);
  else
    fprintf (state_file, " nil ");
}

void
state_writer::write_state_type_option (options_p current)
{
  write_any_indent (0);
  fprintf (state_file, "type ");
  write_state_type (current->info.type);
}

void
state_writer::write_state_nested_option (options_p current)
{
  write_any_indent (0);
  fprintf (state_file, "nested ");
  write_state_type (current->info.nested->type);
  if (current->info.nested->convert_from != NULL)
    write_state_a_string (current->info.nested->convert_from);
  else
    {
      write_any_indent (1);
      fprintf (state_file, " nil ");
    }

  if (current->info.nested->convert_to != NULL)
    write_state_a_string (current->info.nested->convert_to);
  else
    {
      write_any_indent (1);
      fprintf (state_file, " nil ");
    }
}

void
state_writer::write_state_option (options_p current)
{
  begin_s_expr ("option");

  write_any_indent (0);
  if (current->name != NULL)
    fprintf (state_file, "%s ", current->name);
  else
    fprintf (state_file, "nil ");

  switch (current->kind)
    {
    case OPTION_STRING:
      write_state_string_option (current);
      break;
    case OPTION_TYPE:
      write_state_type_option (current);
      break;
    case OPTION_NESTED:
      write_state_nested_option (current);
      break;
    default:
      fatal ("Option tag unknown");
    }

  /* Terminate the "option" s-expression.  */
  end_s_expr ();
}



/* Write a list of GTY options.  */
void
state_writer::write_state_options (options_p opt)
{
  options_p current;

  if (opt == NULL)
    {
        write_any_indent (0);
        fprintf (state_file, "nil ");
      return;
    }

  begin_s_expr ("options");
  for (current = opt; current != NULL; current = current->next)
      write_state_option (current);
  end_s_expr ();
}


/* Write a bitmap representing a set of GCC front-end languages.  */
void
state_writer::write_state_lang_bitmap (lang_bitmap bitmap)
{
  write_any_indent (0);
  fprintf (state_file, "%d ", (int) bitmap);
}

/* Write version information.  */
void
state_writer::write_state_version (const char *version)
{
  begin_s_expr ("version");
  write_state_a_string (version);
  end_s_expr ();
}

/* Write a scalar type.  We have only two of these.  */
void
state_writer::write_state_scalar_type (type_p current)
{
  write_any_indent (0);
  if (current == &scalar_nonchar)
    fprintf (state_file, "scalar_nonchar ");
  else if (current == &scalar_char)
    fprintf (state_file, "scalar_char ");
  else
    fatal ("Unexpected type in write_state_scalar_type");

  write_state_common_type_content (current);
}

/* Write the string type.  There is only one such thing! */
void
state_writer::write_state_string_type (type_p current)
{
  if (current == &string_type)
    {
      write_any_indent (0);
      fprintf (state_file, "string ");
      write_state_common_type_content (current);
    }
  else
    fatal ("Unexpected type in write_state_string_type");
}

/* Write an undefined type.  */
void
state_writer::write_state_undefined_type (type_p current)
{
  DBGPRINTF ("undefined type @ %p #%d '%s'", (void *) current,
             current->state_number, current->u.s.tag);
  write_any_indent (0);
  fprintf (state_file, "undefined ");
  gcc_assert (current->gc_used == GC_UNUSED);
  write_state_common_type_content (current);
  if (current->u.s.tag != NULL)
    write_state_a_string (current->u.s.tag);
  else
    {
      write_any_indent (0);
      fprintf (state_file, "nil");
    }

  write_state_fileloc (type_lineloc (current));
}


/* Common code to write structure like types.  */
void
state_writer::write_state_struct_union_type (type_p current,
                                             const char *kindstr)
{
  DBGPRINTF ("%s type @ %p #%d '%s'", kindstr, (void *) current,
             current->state_number, current->u.s.tag);
  write_any_indent (0);
  fprintf (state_file, "%s ", kindstr);
  write_state_common_type_content (current);
  if (current->u.s.tag != NULL)
    write_state_a_string (current->u.s.tag);
  else
    {
      write_any_indent (0);
      fprintf (state_file, "nil");
    }

  write_state_fileloc (type_lineloc (current));
  write_state_fields (current->u.s.fields);
  write_state_options (current->u.s.opt);
  write_state_lang_bitmap (current->u.s.bitmap);
}


/* Write a GTY struct type.  */
void
state_writer::write_state_struct_type (type_p current)
{
  write_state_struct_union_type (current, "struct");
  write_state_type (current->u.s.lang_struct);
  write_state_type (current->u.s.base_class);
}

/* Write a GTY user-defined struct type.  */
void
state_writer::write_state_user_struct_type (type_p current)
{
  DBGPRINTF ("user_struct type @ %p #%d '%s'", (void *) current,
             current->state_number, current->u.s.tag);
  write_any_indent (0);
  fprintf (state_file, "user_struct ");
  write_state_common_type_content (current);
  if (current->u.s.tag != NULL)
    write_state_a_string (current->u.s.tag);
  else
    {
      write_any_indent (0);
      fprintf (state_file, "nil");
    }
  write_state_fileloc (type_lineloc (current));
  write_state_fields (current->u.s.fields);
}

/* write a GTY union type.  */
void
state_writer::write_state_union_type (type_p current)
{
  write_state_struct_union_type (current, "union");
  write_state_type (current->u.s.lang_struct);
}

/* Write a lang_struct type.  This is tricky and was painful to debug,
   we deal with the next field specifically within their lang_struct
   subfield, which points to a linked list of homonumous types.
   Change this function with extreme care, see also
   read_state_lang_struct_type.  */
void
state_writer::write_state_lang_struct_type (type_p current)
{
  int nbhomontype = 0;
  type_p hty = NULL;
  const char *homoname = 0;
  write_state_struct_union_type (current, "lang_struct");
  /* lang_struct-ures are particularly tricky, since their
     u.s.lang_struct field gives a list of homonymous struct-s or
     union-s! */
  DBGPRINTF ("lang_struct @ %p #%d", (void *) current, current->state_number);
  for (hty = current->u.s.lang_struct; hty != NULL; hty = hty->next)
    {
      nbhomontype++;
      DBGPRINTF ("homonymous #%d hty @ %p #%d '%s'", nbhomontype,
                 (void *) hty, hty->state_number, hty->u.s.tag);
      /* Every member of the homonymous list should have the same tag.  */
      gcc_assert (union_or_struct_p (hty));
      gcc_assert (hty->u.s.lang_struct == current);
      if (!homoname)
        homoname = hty->u.s.tag;
      gcc_assert (strcmp (homoname, hty->u.s.tag) == 0);
    }
  begin_s_expr ("homotypes");
  fprintf (state_file, "%d", nbhomontype);
  for (hty = current->u.s.lang_struct; hty != NULL; hty = hty->next)
    write_state_type (hty);
  end_s_expr ();
}

/* Write a parametrized structure GTY type.  */
void
state_writer::write_state_param_struct_type (type_p current)
{
  int i;

  write_any_indent (0);
  fprintf (state_file, "param_struct ");
  write_state_common_type_content (current);
  write_state_type (current->u.param_struct.stru);
  for (i = 0; i < NUM_PARAM; i++)
    {
      if (current->u.param_struct.param[i] != NULL)
        write_state_type (current->u.param_struct.param[i]);
      else
        {
          write_any_indent (0);
          fprintf (state_file, "nil ");
        }
    }
  write_state_fileloc (&current->u.param_struct.line);
}

/* Write a pointer type.  */
void
state_writer::write_state_pointer_type (type_p current)
{
  write_any_indent (0);
  fprintf (state_file, "pointer ");
  write_state_common_type_content (current);
  write_state_type (current->u.p);
}

/* Write an array type.  */
void
state_writer::write_state_array_type (type_p current)
{
  write_any_indent (0);
  fprintf (state_file, "array ");
  write_state_common_type_content (current);
  if (current->u.a.len != NULL)
    write_state_a_string (current->u.a.len);
  else
    {
      write_any_indent (1);
      fprintf (state_file, " nil");
    }

  write_any_indent (1);
  fprintf (state_file, " ");
  write_state_type (current->u.a.p);
}

/* Write the gc_used information.  */
void
state_writer::write_state_gc_used (enum gc_used_enum gus)
{
  write_any_indent (1);
  switch (gus)
    {
    case GC_UNUSED:
      fprintf (state_file, " gc_unused");
      break;
    case GC_USED:
      fprintf (state_file, " gc_used");
      break;
    case GC_MAYBE_POINTED_TO:
      fprintf (state_file, " gc_maybe_pointed_to");
      break;
    case GC_POINTED_TO:
      fprintf (state_file, " gc_pointed_to");
      break;
    default:
      gcc_unreachable ();
    }
}

/* Utility routine to write the common content of all types.  Notice
   that the next field is *not* written on purpose.  */
void
state_writer::write_state_common_type_content (type_p current)
{
  write_any_indent (0);
  fprintf (state_file, "%d ", current->state_number);
  /* We do not write the next type, because list of types are
     explicitly written.  However, lang_struct are special in that
     respect.  See function write_state_lang_struct_type for more.  */
  write_state_type (current->pointer_to);
  write_state_gc_used (current->gc_used);
}


/* The important and recursive routine writing GTY types as understood
   by gengtype.  Types which have a positive state_number have already
   been seen and written.  */
void
state_writer::write_state_type (type_p current)
{
  write_any_indent (0);
  if (current == NULL)
    {
      fprintf (state_file, "nil ");
      return;
    }

  begin_s_expr ("type");

  if (current->state_number > 0)
    {
      write_any_indent (0);
      fprintf (state_file, "already_seen %d", current->state_number);
    }
  else
    {
      m_state_written_type_count++;
      DBGPRINTF ("writing type #%d @%p old number %d", m_state_written_type_count,
                 (void *) current, current->state_number);
      current->state_number = m_state_written_type_count;
      switch (current->kind)
        {
        case TYPE_NONE:
          gcc_unreachable ();
        case TYPE_UNDEFINED:
          write_state_undefined_type (current);
          break;
        case TYPE_STRUCT:
          write_state_struct_type (current);
          break;
        case TYPE_USER_STRUCT:
          write_state_user_struct_type (current);
          break;
        case TYPE_UNION:
          write_state_union_type (current);
          break;
        case TYPE_POINTER:
          write_state_pointer_type (current);
          break;
        case TYPE_ARRAY:
          write_state_array_type (current);
          break;
        case TYPE_LANG_STRUCT:
          write_state_lang_struct_type (current);
          break;
        case TYPE_PARAM_STRUCT:
          write_state_param_struct_type (current);
          break;
        case TYPE_SCALAR:
          write_state_scalar_type (current);
          break;
        case TYPE_STRING:
          write_state_string_type (current);
          break;
        }
    }

  /* Terminate the "type" s-expression.  */
  end_s_expr ();
}


/* Write a pair.  */
void
state_writer::write_state_pair (pair_p current)
{
  if (current == NULL)
    {
      write_any_indent (0);
      fprintf (state_file, "nil)");
      return;
    }

  begin_s_expr ("pair");

  if (current->name != NULL)
    write_state_a_string (current->name);
  else
    write_state_a_string ("nil");

  write_state_type (current->type);
  write_state_fileloc (&(current->line));
  write_state_options (current->opt);

  /* Terminate the "pair" s-expression.  */
  end_s_expr ();
}

/* Write a pair list and return the number of pairs written.  */
int
state_writer::write_state_pair_list (pair_p list)
{
  int nbpair = 0;
  pair_p current;

  for (current = list; current != NULL; current = current->next)
    {
      write_state_pair (current);
      nbpair++;
    }
  return nbpair;

}

/* When writing imported linked lists, like typedefs, structures,
   param_structs, ... we count their length first and write it.  These
   eases the reading, and enables an extra verification on the number
   of actually read items.  */

/* Write our typedefs.  */
void
state_writer::write_state_typedefs (void)
{
  int nbtypedefs = pair_list_length (typedefs);
  int nbpairs = 0;
  begin_s_expr ("typedefs");
  fprintf (state_file, "%d", nbtypedefs);
  nbpairs = write_state_pair_list (typedefs);
  gcc_assert (nbpairs == nbtypedefs);
  end_s_expr ();
  if (verbosity_level >= 2)
    printf ("%s wrote %d typedefs\n", progname, nbtypedefs);
}

/* Write our structures.  */
void
state_writer::write_state_structures (void)
{
  int nbstruct = 0;
  type_p current;

  for (current = structures; current != NULL; current = current->next)
    nbstruct++;

  begin_s_expr ("structures");
  fprintf (state_file, "%d", nbstruct);

  for (current = structures; current != NULL; current = current->next)
    {
      write_new_line ();
      write_state_type (current);
    }

  /* Terminate the "structures" s-expression.  */
  end_s_expr ();
  if (verbosity_level >= 2)
    printf ("%s wrote %d structures in state\n", progname, nbstruct);
}

/* Write our param_struct-s.  */
void
state_writer::write_state_param_structs (void)
{
  int nbparamstruct = 0;
  type_p current;

  for (current = param_structs; current != NULL; current = current->next)
    nbparamstruct++;

  begin_s_expr ("param_structs");
  fprintf (state_file, "%d", nbparamstruct);

  for (current = param_structs; current != NULL; current = current->next)
    write_state_type (current);

  end_s_expr ();
}

/* Write our variables.  */
void
state_writer::write_state_variables (void)
{
  int nbvars = pair_list_length (variables);
  int nbpairs = 0;
  begin_s_expr ("variables");
  fprintf (state_file, "%d", nbvars);
  nbpairs = write_state_pair_list (variables);
  gcc_assert (nbpairs == nbvars);
  end_s_expr ();
  if (verbosity_level >= 2)
    printf ("%s wrote %d variables.\n", progname, nbvars);
}

/* Write the source directory.  File locations within the source
   directory have been written specifically.  */
void
state_writer::write_state_srcdir (void)
{
  begin_s_expr ("srcdir");
  write_state_a_string (srcdir);
  end_s_expr ();
}

/* Count and write the list of our files.  */
void
state_writer::write_state_files_list (void)
{
  int i = 0;
  /* Write the list of files with their lang_bitmap.  */
  begin_s_expr ("fileslist");
  fprintf (state_file, "%d", (int) num_gt_files);
  for (i = 0; i < (int) num_gt_files; i++)
    {
      const char *cursrcrelpath = NULL;
      const input_file *curfil = gt_files[i];
      /* Most of the files are inside $(srcdir) so it is worth to
         handle them specially.  */
      cursrcrelpath = get_file_srcdir_relative_path (curfil);
      if (cursrcrelpath)
        {
          begin_s_expr ("srcfile");
          fprintf (state_file, "%d ", get_lang_bitmap (curfil));
          write_state_a_string (cursrcrelpath);
        }
      else
        {
          begin_s_expr ("file");
          fprintf (state_file, "%d ", get_lang_bitmap (curfil));
          write_state_a_string (get_input_file_name (curfil));
        }
      /* Terminate the inner s-expression (either "srcfile" or "file").   */
      end_s_expr ();
    }
  /* Terminate the "fileslist" s-expression.  */
  end_s_expr ();
}

/* Write the list of GCC front-end languages.  */
void
state_writer::write_state_languages (void)
{
  int i = 0;
  begin_s_expr ("languages");
  fprintf (state_file, "%d", (int) num_lang_dirs);
  for (i = 0; i < (int) num_lang_dirs; i++)
    {
      /* Languages names are identifiers, we expect only letters or
         underscores or digits in them.  In particular, C++ is not a
         valid language name, but cp is valid.  */
      fprintf (state_file, " %s", lang_dir_names[i]);
    }
  end_s_expr ();
}

/* Write the trailer.  */
static void
write_state_trailer (void)
{
  /* This test should probably catch IO errors like disk full...  */
  if (fputs ("\n(!endfile)\n", state_file) == EOF)
    fatal ("failed to write state trailer [%s]", xstrerror (errno));
}

/* The write_state routine is the only writing routine called by main
   in gengtype.c.  To avoid messing the state if gengtype is
   interrupted or aborted, we write a temporary file and rename it
   after having written it in totality.  */
void
write_state (const char *state_path)
{
  long statelen = 0;
  time_t now = 0;
  char *temp_state_path = NULL;
  char tempsuffix[40];
  time (&now);

  /* We write a unique temporary file which is renamed when complete
   * only.  So even if gengtype is interrupted, the written state file
   * won't be partially written, since the temporary file is not yet
   * renamed in that case.  */
  memset (tempsuffix, 0, sizeof (tempsuffix));
  snprintf (tempsuffix, sizeof (tempsuffix) - 1, "-%ld-%d.tmp", (long) now,
            (int) getpid ());
  temp_state_path = concat (state_path, tempsuffix, NULL);
  state_file = fopen (temp_state_path, "w");
  if (state_file == NULL)
    fatal ("Failed to open file %s for writing state: %s",
           temp_state_path, xstrerror (errno));
  if (verbosity_level >= 3)
    printf ("%s writing state file %s temporarily in %s\n",
            progname, state_path, temp_state_path);
  /* This is the first line of the state.  Perhaps the file utility
     could know about that, so don't change it often.  */
  fprintf (state_file, ";;;;@@@@ GCC gengtype state\n");
  /* Output a few comments for humans. */
  fprintf (state_file,
           ";;; DON'T EDIT THIS FILE, since generated by GCC's gengtype\n");
  fprintf (state_file,
           ";;; The format of this file is tied to a particular version of GCC.\n");
  fprintf (state_file,
           ";;; Don't parse this file wihout knowing GCC gengtype internals.\n");
  fprintf (state_file,
           ";;; This file should be parsed by the same %s which wrote it.\n",
           progname);

  state_writer sw;

  /* The first non-comment significant line gives the version string.  */
  sw.write_state_version (version_string);
  sw.write_state_srcdir ();
  sw.write_state_languages ();
  sw.write_state_files_list ();
  sw.write_state_structures ();
  sw.write_state_typedefs ();
  sw.write_state_param_structs ();
  sw.write_state_variables ();
  write_state_trailer ();
  statelen = ftell (state_file);
  if (ferror (state_file))
    fatal ("output error when writing state file %s [%s]",
           temp_state_path, xstrerror (errno));
  if (fclose (state_file))
    fatal ("failed to close state file %s [%s]",
           temp_state_path, xstrerror (errno));
  if (rename (temp_state_path, state_path))
    fatal ("failed to rename %s to state file %s [%s]", temp_state_path,
           state_path, xstrerror (errno));
  free (temp_state_path);

  if (verbosity_level >= 1)
    printf ("%s wrote state file %s of %ld bytes with %d GTY-ed types\n",
            progname, state_path, statelen, sw.m_state_written_type_count);

}
\f
/** End of writing routines!  The corresponding reading routines follow.  **/



/* Forward declarations, since some read_state_* functions are
   recursive! */
static void read_state_fileloc (struct fileloc *line);
static void read_state_options (options_p *opt);
static void read_state_type (type_p *current);
static void read_state_pair (pair_p *pair);
/* Return the number of pairs actually read.  */
static int read_state_pair_list (pair_p *list);
static void read_state_fields (pair_p *fields);
static void read_state_common_type_content (type_p current);




/* Record into the state_seen_types hash-table a type which we are
   reading, to enable recursive or circular references to it.  */
static void
record_type (type_p type)
{
  PTR *slot;

  slot = htab_find_slot (state_seen_types, type, INSERT);
  gcc_assert (slot);

  *slot = type;
}

/* Read an already seen type.  */
static void
read_state_already_seen_type (type_p *type)
{
  struct state_token_st *t0 = peek_state_token (0);

  if (state_token_kind (t0) == STOK_INTEGER)
    {
      PTR *slot = NULL;
      struct type loctype = { TYPE_SCALAR, 0, 0, 0, GC_UNUSED, {0} };

      loctype.state_number = t0->stok_un.stok_num;
      slot = htab_find_slot (state_seen_types, &loctype, NO_INSERT);
      if (slot == NULL)
        {
          fatal_reading_state (t0, "Unknown type");
        }

      next_state_tokens (1);
      *type = (type_p) *slot;
    }
  else
    {
      fatal_reading_state (t0, "Bad seen type");
    }
}


/* Read the scalar_nonchar type.  */
static void
read_state_scalar_nonchar_type (type_p *type)
{
  *type = &scalar_nonchar;
  read_state_common_type_content (*type);
}


/* Read the scalar_char type.  */
static void
read_state_scalar_char_type (type_p *type)
{
  *type = &scalar_char;
  read_state_common_type_content (*type);
}

/* Read the string_type.  */
static void
read_state_string_type (type_p *type)
{
  *type = &string_type;
  read_state_common_type_content (*type);
}


/* Read a lang_bitmap representing a set of GCC front-end languages.  */
static void
read_state_lang_bitmap (lang_bitmap *bitmap)
{
  struct state_token_st *t;

  t = peek_state_token (0);
  if (state_token_kind (t) == STOK_INTEGER)
    {
      *bitmap = t->stok_un.stok_num;
      next_state_tokens (1);
    }
  else
    {
      fatal_reading_state (t, "Bad syntax for bitmap");
    }
}


/* Read an undefined type.  */
static void
read_state_undefined_type (type_p type)
{
  struct state_token_st *t0;

  type->kind = TYPE_UNDEFINED;
  read_state_common_type_content (type);
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      if (state_token_is_name (t0, "nil"))
        {
          type->u.s.tag = NULL;
          DBGPRINTF ("read anonymous undefined type @%p #%d",
                     (void *) type, type->state_number);
        }
      else
        {
          type->u.s.tag = xstrdup (t0->stok_un.stok_string);
          DBGPRINTF ("read undefined type @%p #%d '%s'",
                     (void *) type, type->state_number, type->u.s.tag);
        }

      next_state_tokens (1);
      read_state_fileloc (&(type->u.s.line));
    }
  else
    {
      fatal_reading_state (t0, "Bad tag in undefined type");
    }
}


/* Read a GTY-ed struct type.  */
static void
read_state_struct_type (type_p type)
{
  struct state_token_st *t0;

  type->kind = TYPE_STRUCT;
  read_state_common_type_content (type);
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      if (state_token_is_name (t0, "nil"))
        {
          type->u.s.tag = NULL;
          DBGPRINTF ("read anonymous struct type @%p #%d",
                     (void *) type, type->state_number);
        }
      else
        {
          type->u.s.tag = xstrdup (t0->stok_un.stok_string);
          DBGPRINTF ("read struct type @%p #%d '%s'",
                     (void *) type, type->state_number, type->u.s.tag);
        }

      next_state_tokens (1);
      read_state_fileloc (&(type->u.s.line));
      read_state_fields (&(type->u.s.fields));
      read_state_options (&(type->u.s.opt));
      read_state_lang_bitmap (&(type->u.s.bitmap));
      read_state_type (&(type->u.s.lang_struct));
      read_state_type (&(type->u.s.base_class));
    }
  else
    {
      fatal_reading_state (t0, "Bad tag in struct type");
    }
}


/* Read a GTY-ed user-provided struct TYPE.  */

static void
read_state_user_struct_type (type_p type)
{
  struct state_token_st *t0;

  type->kind = TYPE_USER_STRUCT;
  read_state_common_type_content (type);
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      if (state_token_is_name (t0, "nil"))
        {
          type->u.s.tag = NULL;
          DBGPRINTF ("read anonymous struct type @%p #%d",
                     (void *) type, type->state_number);
        }
      else
        {
          type->u.s.tag = xstrdup (t0->stok_un.stok_string);
          DBGPRINTF ("read struct type @%p #%d '%s'",
                     (void *) type, type->state_number, type->u.s.tag);
        }

      next_state_tokens (1);
      read_state_fileloc (&(type->u.s.line));
      read_state_fields (&(type->u.s.fields));
    }
  else
    {
      fatal_reading_state (t0, "Bad tag in user-struct type");
    }
}


/* Read a GTY-ed union type.  */
static void
read_state_union_type (type_p type)
{
  struct state_token_st *t0;

  type->kind = TYPE_UNION;
  read_state_common_type_content (type);
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      if (state_token_is_name (t0, "nil"))
        {
          type->u.s.tag = NULL;
          DBGPRINTF ("read anonymous union type @%p #%d",
                     (void *) type, type->state_number);
        }
      else
        {
          type->u.s.tag = xstrdup (t0->stok_un.stok_string);
          DBGPRINTF ("read union type @%p #%d '%s'",
                     (void *) type, type->state_number, type->u.s.tag);
        }
      next_state_tokens (1);
      read_state_fileloc (&(type->u.s.line));
      read_state_fields (&(type->u.s.fields));
      read_state_options (&(type->u.s.opt));
      read_state_lang_bitmap (&(type->u.s.bitmap));
      read_state_type (&(type->u.s.lang_struct));
    }
  else
    fatal_reading_state (t0, "Bad tag in union type");
}


/* Read a GTY-ed pointer type.  */
static void
read_state_pointer_type (type_p type)
{
  type->kind = TYPE_POINTER;
  read_state_common_type_content (type);
  DBGPRINTF ("read pointer type @%p #%d", (void *) type, type->state_number);
  read_state_type (&(type->u.p));
}


/* Read a GTY-ed array type.  */
static void
read_state_array_type (type_p type)
{
  struct state_token_st *t0;

  type->kind = TYPE_ARRAY;
  read_state_common_type_content (type);
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      type->u.a.len = xstrdup (t0->stok_un.stok_string);
      DBGPRINTF ("read array type @%p #%d length '%s'",
                 (void *) type, type->state_number, type->u.a.len);
      next_state_tokens (1);
    }

  else if (state_token_is_name (t0, "nil"))
    {
      type->u.a.len = NULL;
      DBGPRINTF ("read array type @%p #%d without length",
                 (void *) type, type->state_number);
      next_state_tokens (1);
    }

  else
    fatal_reading_state (t0, "Bad array name type");
  read_state_type (&(type->u.a.p));
}



/* Read a lang_struct type for GTY-ed struct-s which depends upon GCC
   front-end languages.  This is a tricky function and it was painful
   to debug.  Change it with extreme care.  See also
   write_state_lang_struct_type.  */
static void
read_state_lang_struct_type (type_p type)
{
  struct state_token_st *t0 = NULL;
  struct state_token_st *t1 = NULL;
  struct state_token_st *t2 = NULL;

  type->kind = TYPE_LANG_STRUCT;
  read_state_common_type_content (type);
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      if (state_token_is_name (t0, "nil"))
        {
          DBGPRINTF ("read anonymous lang_struct type @%p #%d",
                     (void *) type, type->state_number);
          type->u.s.tag = NULL;
        }
      else
        {
          type->u.s.tag = xstrdup (t0->stok_un.stok_string);
          DBGPRINTF ("read lang_struct type @%p #%d '%s'",
                     (void *) type, type->state_number, type->u.s.tag);
        }
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Bad tag in lang struct type");
  read_state_fileloc (&(type->u.s.line));
  read_state_fields (&(type->u.s.fields));
  read_state_options (&(type->u.s.opt));
  read_state_lang_bitmap (&(type->u.s.bitmap));
  /* Within lang_struct-ures, the lang_struct field is a linked list
     of homonymous types! */
  t0 = peek_state_token (0);
  t1 = peek_state_token (1);
  t2 = peek_state_token (2);
  /* Parse (!homotypes <number-types> <type-1> .... <type-n>) */
  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!homotypes")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      type_p *prevty = &type->u.s.lang_struct;
      int nbhomotype = t2->stok_un.stok_num;
      int i = 0;
      t0 = t1 = t2 = NULL;
      next_state_tokens (3);
      for (i = 0; i < nbhomotype; i++)
        {
          read_state_type (prevty);
          t0 = peek_state_token (0);
          if (*prevty)
            prevty = &(*prevty)->next;
          else
              fatal_reading_state (t0,
                                   "expecting type in homotype list for lang_struct");
        };
      if (state_token_kind (t0) != STOK_RIGHTPAR)
        fatal_reading_state (t0,
                             "expecting ) in homotype list for lang_struct");
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "expecting !homotypes for lang_struct");
}


/* Read a param_struct type for GTY parametrized structures.  */
static void
read_state_param_struct_type (type_p type)
{
  int i;
  struct state_token_st *t0;

  type->kind = TYPE_PARAM_STRUCT;
  read_state_common_type_content (type);
  DBGPRINTF ("read param_struct type @%p #%d",
             (void *) type, type->state_number);
  read_state_type (&(type->u.param_struct.stru));

  for (i = 0; i < NUM_PARAM; i++)
    {
      t0 = peek_state_token (0);
      if (state_token_is_name (t0, "nil"))
        {
          type->u.param_struct.param[i] = NULL;
          next_state_tokens (1);
        }
      else
        read_state_type (&(type->u.param_struct.param[i]));
    }
  read_state_fileloc (&(type->u.param_struct.line));
}


/* Read the gc used information.  */
static void
read_state_gc_used (enum gc_used_enum *pgus)
{
  struct state_token_st *t0 = peek_state_token (0);
  if (state_token_is_name (t0, "gc_unused"))
    *pgus = GC_UNUSED;
  else if (state_token_is_name (t0, "gc_used"))
    *pgus = GC_USED;
  else if (state_token_is_name (t0, "gc_maybe_pointed_to"))
    *pgus = GC_MAYBE_POINTED_TO;
  else if (state_token_is_name (t0, "gc_pointed_to"))
    *pgus = GC_POINTED_TO;
  else
    fatal_reading_state (t0, "invalid gc_used information");
  next_state_tokens (1);
}


/* Utility function to read the common content of types.  */
static void
read_state_common_type_content (type_p current)
{
  struct state_token_st *t0 = peek_state_token (0);

  if (state_token_kind (t0) == STOK_INTEGER)
    {
      current->state_number = t0->stok_un.stok_num;
      next_state_tokens (1);
      record_type (current);
    }
  else
      fatal_reading_state_printf (t0,
                                  "Expected integer for state_number line %d",
                                  state_line);
  /* We don't read the next field of the type.  */
  read_state_type (&current->pointer_to);
  read_state_gc_used (&current->gc_used);
}


/* Read a GTY-ed type.  */
void
read_state_type (type_p *current)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);

  if (state_token_kind (t0) == STOK_LEFTPAR &&
      state_token_is_name (t1, "!type"))
    {
      next_state_tokens (2);
      t0 = peek_state_token (0);
      if (state_token_is_name (t0, "already_seen"))
        {
          next_state_tokens (1);
          read_state_already_seen_type (current);
        }
      else
        {
          t0 = peek_state_token (0);

          if (state_token_is_name (t0, "scalar_nonchar"))
            {
              next_state_tokens (1);
              read_state_scalar_nonchar_type (current);
            }
          else if (state_token_is_name (t0, "scalar_char"))
            {
              next_state_tokens (1);
              read_state_scalar_char_type (current);
            }
          else if (state_token_is_name (t0, "string"))
            {
              next_state_tokens (1);
              read_state_string_type (current);
            }
          else if (state_token_is_name (t0, "undefined"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_undefined_type (*current);
            }
          else if (state_token_is_name (t0, "struct"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_struct_type (*current);
            }
          else if (state_token_is_name (t0, "union"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_union_type (*current);
            }
          else if (state_token_is_name (t0, "lang_struct"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_lang_struct_type (*current);
            }
          else if (state_token_is_name (t0, "param_struct"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_param_struct_type (*current);
            }
          else if (state_token_is_name (t0, "pointer"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_pointer_type (*current);
            }
          else if (state_token_is_name (t0, "array"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_array_type (*current);
            }
          else if (state_token_is_name (t0, "user_struct"))
            {
              *current = XCNEW (struct type);
              next_state_tokens (1);
              read_state_user_struct_type (*current);
            }
          else
            fatal_reading_state (t0, "bad type in (!type");
        }
      t0 = peek_state_token (0);
      if (state_token_kind (t0) != STOK_RIGHTPAR)
        fatal_reading_state (t0, "missing ) in type");
      next_state_tokens (1);
    }
  else if (state_token_is_name (t0, "nil"))
    {
      next_state_tokens (1);
      *current = NULL;
    }
  else
    fatal_reading_state (t0, "bad type syntax");
}


/* Read a file location.  Files within the source directory are dealt
   with specifically.  */
void
read_state_fileloc (struct fileloc *floc)
{
  bool issrcfile = false;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);

  gcc_assert (floc != NULL);
  gcc_assert (srcdir != NULL);

  if (state_token_kind (t0) == STOK_LEFTPAR &&
      (state_token_is_name (t1, "!fileloc")
       || (issrcfile = state_token_is_name (t1, "!srcfileloc"))))
    {
      next_state_tokens (2);
      t0 = peek_state_token (0);
      t1 = peek_state_token (1);
      if (state_token_kind (t0) == STOK_STRING &&
          state_token_kind (t1) == STOK_INTEGER)
        {
          char *path = t0->stok_un.stok_string;
          if (issrcfile)
            {
              static const char dirsepstr[2] = { DIR_SEPARATOR, (char) 0 };
              char *fullpath = concat (srcdir, dirsepstr, path, NULL);
              floc->file = input_file_by_name (fullpath);
              free (fullpath);
            }
          else
            floc->file = input_file_by_name (path);
          floc->line = t1->stok_un.stok_num;
          next_state_tokens (2);
        }
      else
        fatal_reading_state (t0,
                             "Bad fileloc syntax, expected path string and line");
      t0 = peek_state_token (0);
      if (state_token_kind (t0) != STOK_RIGHTPAR)
        fatal_reading_state (t0, "Bad fileloc syntax, expected )");
      next_state_tokens (1);
    }
  else if (state_token_is_name (t0, "nil"))
    {
      next_state_tokens (1);
      floc->file = NULL;
      floc->line = 0;
    }
  else
    fatal_reading_state (t0, "Bad fileloc syntax");
}


/* Read the fields of a GTY-ed type.  */
void
read_state_fields (pair_p *fields)
{
  pair_p tmp = NULL;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!fields")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      int nbfields = t2->stok_un.stok_num;
      int nbpairs = 0;
      next_state_tokens (3);
      nbpairs = read_state_pair_list (&tmp);
      t0 = peek_state_token (0);
      if (nbpairs != nbfields)
        fatal_reading_state_printf
          (t0,
           "Mismatched fields number, expected %d got %d", nbpairs, nbfields);
      if (state_token_kind (t0) == STOK_RIGHTPAR)
        next_state_tokens (1);
      else
        fatal_reading_state (t0, "Bad fields expecting )");
    }

  *fields = tmp;
}


/* Read a string option.  */
static void
read_state_string_option (options_p opt)
{
  struct state_token_st *t0 = peek_state_token (0);
  opt->kind = OPTION_STRING;
  if (state_token_kind (t0) == STOK_STRING)
    {
      opt->info.string = xstrdup (t0->stok_un.stok_string);
      next_state_tokens (1);
    }
  else if (state_token_is_name (t0, "nil"))
    {
      opt->info.string = NULL;
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Missing name in string option");
}


/* Read a type option.  */
static void
read_state_type_option (options_p opt)
{
  opt->kind = OPTION_TYPE;
  read_state_type (&(opt->info.type));
}


/* Read a nested option.  */
static void
read_state_nested_option (options_p opt)
{
  struct state_token_st *t0;

  opt->info.nested = XCNEW (struct nested_ptr_data);
  opt->kind = OPTION_NESTED;
  read_state_type (&(opt->info.nested->type));
  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      opt->info.nested->convert_from = xstrdup (t0->stok_un.stok_string);
      next_state_tokens (1);
    }
  else if (state_token_is_name (t0, "nil"))
    {
      opt->info.nested->convert_from = NULL;
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Bad nested convert_from option");

  t0 = peek_state_token (0);
  if (state_token_kind (t0) == STOK_STRING)
    {
      opt->info.nested->convert_to = xstrdup (t0->stok_un.stok_string);
      next_state_tokens (1);
    }
  else if (state_token_is_name (t0, "nil"))
    {
      opt->info.nested->convert_to = NULL;
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Bad nested convert_from option");
}


/* Read an GTY option.  */
static void
read_state_option (options_p *opt)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);

  if (state_token_kind (t0) == STOK_LEFTPAR &&
      state_token_is_name (t1, "!option"))
    {
      next_state_tokens (2);
      t0 = peek_state_token (0);
      if (state_token_kind (t0) == STOK_NAME)
        {
          *opt = XCNEW (struct options);
          if (state_token_is_name (t0, "nil"))
            (*opt)->name = NULL;
          else
            (*opt)->name = t0->stok_un.stok_ident->stid_name;
          next_state_tokens (1);
          t0 = peek_state_token (0);
          if (state_token_kind (t0) == STOK_NAME)
            {
              if (state_token_is_name (t0, "string"))
                {
                  next_state_tokens (1);
                  read_state_string_option (*opt);
                }
              else if (state_token_is_name (t0, "type"))
                {
                  next_state_tokens (1);
                  read_state_type_option (*opt);
                }
              else if (state_token_is_name (t0, "nested"))
                {
                  next_state_tokens (1);
                  read_state_nested_option (*opt);
                }
              else
                fatal_reading_state (t0, "Bad option type");
              t0 = peek_state_token (0);
              if (state_token_kind (t0) != STOK_RIGHTPAR)
                fatal_reading_state (t0, "Bad syntax in option, expecting )");

              next_state_tokens (1);
            }
          else
            fatal_reading_state (t0, "Missing option type");
        }
      else
        fatal_reading_state (t0, "Bad name for option");
    }
  else
    fatal_reading_state (t0, "Bad option, waiting for )");
}

/* Read a list of options.  */
void
read_state_options (options_p *opt)
{
  options_p head = NULL;
  options_p previous = NULL;
  options_p current_option = NULL;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);

  if (state_token_kind (t0) == STOK_LEFTPAR &&
      state_token_is_name (t1, "!options"))
    {
      next_state_tokens (2);
      t0 = peek_state_token (0);
      while (state_token_kind (t0) != STOK_RIGHTPAR)
        {
          read_state_option (&current_option);
          if (head == NULL)
            {
              head = current_option;
              previous = head;
            }
          else
            {
              previous->next = current_option;
              previous = current_option;
            }
          t0 = peek_state_token (0);
        }
      next_state_tokens (1);
    }
  else if (state_token_is_name (t0, "nil"))
    {
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Bad options syntax");

  *opt = head;
}


/* Read a version, and check against the version of the gengtype.  */
static void
read_state_version (const char *version_string)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);

  if (state_token_kind (t0) == STOK_LEFTPAR &&
      state_token_is_name (t1, "!version"))
    {
      next_state_tokens (2);
      t0 = peek_state_token (0);
      t1 = peek_state_token (1);
      if (state_token_kind (t0) == STOK_STRING &&
          state_token_kind (t1) == STOK_RIGHTPAR)
        {
          /* Check that the read version string is the same as current
             version.  */
          if (strcmp (version_string, t0->stok_un.stok_string))
            fatal_reading_state_printf (t0,
                                        "version string mismatch; expecting %s but got %s",
                                        version_string,
                                        t0->stok_un.stok_string);
          next_state_tokens (2);
        }
      else
        fatal_reading_state (t0, "Missing version or right parenthesis");
    }
  else
    fatal_reading_state (t0, "Bad version syntax");
}


/* Read a pair.  */
void
read_state_pair (pair_p *current)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  if (state_token_kind (t0) == STOK_LEFTPAR &&
      state_token_is_name (t1, "!pair"))
    {
      *current = XCNEW (struct pair);
      next_state_tokens (2);
      t0 = peek_state_token (0);
      if (state_token_kind (t0) == STOK_STRING)
        {
          if (strcmp (t0->stok_un.stok_string, "nil") == 0)
            {
              (*current)->name = NULL;
            }
          else
            {
              (*current)->name = xstrdup (t0->stok_un.stok_string);
            }
          next_state_tokens (1);
          read_state_type (&((*current)->type));
          read_state_fileloc (&((*current)->line));
          read_state_options (&((*current)->opt));;
          t0 = peek_state_token (0);
          if (state_token_kind (t0) == STOK_RIGHTPAR)
            {
              next_state_tokens (1);
            }
          else
            {
              fatal_reading_state (t0, "Bad syntax for pair, )");
            }
        }
      else
        {
          fatal_reading_state (t0, "Bad name for pair");
        }
    }
  else if (state_token_kind (t0) == STOK_NAME &&
           state_token_is_name (t0, "nil"))
    {
      next_state_tokens (1);
      *current = NULL;
    }
  else
    fatal_reading_state_printf (t0, "Bad syntax for pair, (!pair %d",
                                state_token->stok_kind);
}


/* Return the number of pairs actually read.  */
int
read_state_pair_list (pair_p *list)
{
  int nbpair = 0;
  pair_p head = NULL;
  pair_p previous = NULL;
  pair_p tmp = NULL;
  struct state_token_st *t0 = peek_state_token (0);
  while (t0 && state_token_kind (t0) != STOK_RIGHTPAR)
    {
      read_state_pair (&tmp);
      if (head == NULL)
        {
          head = tmp;
          previous = head;
        }
      else
        {
          previous->next = tmp;
          previous = tmp;
        }
      t0 = peek_state_token (0);
      nbpair++;
    }

  /* don't consume the ); the caller will eat it.  */
  *list = head;
  return nbpair;
}

/* Read the typedefs.  */
static void
read_state_typedefs (pair_p *typedefs)
{
  int nbtypedefs = 0;
  pair_p list = NULL;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!typedefs")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      int nbpairs = 0;
      nbtypedefs = t2->stok_un.stok_num;
      next_state_tokens (3);
      nbpairs = read_state_pair_list (&list);
      t0 = peek_state_token (0);
      if (nbpairs != nbtypedefs)
        fatal_reading_state_printf
          (t0,
           "invalid number of typedefs, expected %d but got %d",
           nbtypedefs, nbpairs);
      if (state_token_kind (t0) == STOK_RIGHTPAR)
        next_state_tokens (1);
      else
        fatal_reading_state (t0, "Bad typedefs syntax )");
    }
  else
    fatal_reading_state (t0, "Bad typedefs syntax (!typedefs");

  if (verbosity_level >= 2)
    printf ("%s read %d typedefs from state\n", progname, nbtypedefs);
  *typedefs = list;
}


/* Read the structures.  */
static void
read_state_structures (type_p *structures)
{
  type_p head = NULL;
  type_p previous = NULL;
  type_p tmp;
  int nbstruct = 0, countstruct = 0;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!structures")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      nbstruct = t2->stok_un.stok_num;
      next_state_tokens (3);
      t0 = peek_state_token (0);
      while (t0 && state_token_kind (t0) != STOK_RIGHTPAR)
        {
          tmp = NULL;
          read_state_type (&tmp);
          countstruct++;
          if (head == NULL)
            {
              head = tmp;
              previous = head;
            }
          else
            {
              previous->next = tmp;
              previous = tmp;
            }
          t0 = peek_state_token (0);
        }
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Bad structures syntax");
  if (countstruct != nbstruct)
    fatal_reading_state_printf (NULL_STATE_TOKEN, 
                                "expected %d structures but got %d",
                                nbstruct, countstruct);
  if (verbosity_level >= 2)
    printf ("%s read %d structures from state\n", progname, nbstruct);
  *structures = head;
}


/* Read the param_struct-s.  */
static void
read_state_param_structs (type_p *param_structs)
{
  int nbparamstructs = 0;
  int countparamstructs = 0;
  type_p head = NULL;
  type_p previous = NULL;
  type_p tmp;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!param_structs")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      nbparamstructs = t2->stok_un.stok_num;
      next_state_tokens (3);
      t0 = t1 = t2 = NULL;
      t0 = peek_state_token (0);
      while (state_token_kind (t0) != STOK_RIGHTPAR)
        {
          tmp = NULL;
          read_state_type (&tmp);
          if (head == NULL)
            {
              head = tmp;
              previous = head;
            }
          else
            {
              previous->next = tmp;
              previous = tmp;
            }
          t0 = peek_state_token (0);
          countparamstructs++;
        }
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "Bad param_structs syntax");
  t0 = peek_state_token (0);
  if (countparamstructs != nbparamstructs)
    fatal_reading_state_printf
      (t0,
       "invalid number of param_structs expected %d got %d",
       nbparamstructs, countparamstructs);
  *param_structs = head;
}


/* Read the variables.  */
static void
read_state_variables (pair_p *variables)
{
  pair_p list = NULL;
  int nbvars = 0;
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!variables")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      int nbpairs = 0;
      nbvars = t2->stok_un.stok_num;
      next_state_tokens (3);
      nbpairs = read_state_pair_list (&list);
      t0 = peek_state_token (0);
      if (nbpairs != nbvars)
        fatal_reading_state_printf
          (t0, "Invalid number of variables, expected %d but got %d",
           nbvars, nbpairs);
      if (state_token_kind (t0) == STOK_RIGHTPAR)
        next_state_tokens (1);
      else
        fatal_reading_state (t0, "Waiting for ) in variables");
    }
  else
    fatal_reading_state (t0, "Bad variables syntax");
  *variables = list;
  if (verbosity_level >= 2)
    printf ("%s read %d variables from state\n", progname, nbvars);
}


/* Read the source directory.  */
static void
read_state_srcdir (void)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  if (state_token_kind (t0) == STOK_LEFTPAR &&
      state_token_is_name (t1, "!srcdir"))
    {
      next_state_tokens (2);
      t0 = peek_state_token (0);
      t1 = peek_state_token (1);
      if (state_token_kind (t0) == STOK_STRING &&
          state_token_kind (t1) == STOK_RIGHTPAR)
        {
          srcdir = xstrdup (t0->stok_un.stok_string);
          srcdir_len = strlen (srcdir);
          next_state_tokens (2);
          return;
        }
    }

  fatal_reading_state (t0, "Bad srcdir in state_file");
}


/* Read the sequence of GCC front-end languages.  */
static void
read_state_languages (void)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);
  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!languages")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      int i = 0;
      num_lang_dirs = t2->stok_un.stok_num;
      lang_dir_names = XCNEWVEC (const char *, num_lang_dirs);
      next_state_tokens (3);
      t0 = t1 = t2 = NULL;
      for (i = 0; i < (int) num_lang_dirs; i++)
        {
          t0 = peek_state_token (0);
          if (state_token_kind (t0) != STOK_NAME)
            fatal_reading_state (t0, "expecting language name in state file");
          lang_dir_names[i] = t0->stok_un.stok_ident->stid_name;
          next_state_tokens (1);
        }
      t0 = peek_state_token (0);
      if (state_token_kind (t0) != STOK_RIGHTPAR)
        fatal_reading_state (t0, "missing ) in languages list of state file");
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "expecting languages list in state file");

}

/* Read the sequence of files.  */
static void
read_state_files_list (void)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!fileslist")
      && state_token_kind (t2) == STOK_INTEGER)
    {
      int i = 0;
      num_gt_files = t2->stok_un.stok_num;
      next_state_tokens (3);
      t0 = t1 = t2 = NULL;
      gt_files = XCNEWVEC (const input_file *, num_gt_files);
      for (i = 0; i < (int) num_gt_files; i++)
        {
          bool issrcfile = FALSE;
          t0 = t1 = t2 = NULL;
          t0 = peek_state_token (0);
          t1 = peek_state_token (1);
          t2 = peek_state_token (2);
          if (state_token_kind (t0) == STOK_LEFTPAR
              && (state_token_is_name (t1, "!file")
                  || (issrcfile = state_token_is_name (t1, "!srcfile")))
              && state_token_kind (t2) == STOK_INTEGER)
            {
              lang_bitmap bmap = t2->stok_un.stok_num;
              next_state_tokens (3);
              t0 = t1 = t2 = NULL;
              t0 = peek_state_token (0);
              t1 = peek_state_token (1);
              if (state_token_kind (t0) == STOK_STRING
                  && state_token_kind (t1) == STOK_RIGHTPAR)
                {
                  const char *fnam = t0->stok_un.stok_string;
                  /* Allocate & fill a gt_file entry with space for the lang_bitmap before! */
                  input_file *curgt = NULL;
                  if (issrcfile)
                    {
                      static const char dirsepstr[2] =
                        { DIR_SEPARATOR, (char) 0 };
                      char *fullpath = concat (srcdir, dirsepstr, fnam, NULL);
                      curgt = input_file_by_name (fullpath);
                      free (fullpath);
                    }
                  else
                    curgt = input_file_by_name (fnam);
                  set_lang_bitmap (curgt, bmap);
                  gt_files[i] = curgt;
                  next_state_tokens (2);
                }
              else
                fatal_reading_state (t0,
                                     "bad file in !fileslist of state file");
            }
          else
            fatal_reading_state (t0,
                                 "expecting file in !fileslist of state file");
        };
      t0 = peek_state_token (0);
      if (!state_token_kind (t0) == STOK_RIGHTPAR)
        fatal_reading_state (t0, "missing ) for !fileslist in state file");
      next_state_tokens (1);
    }
  else
    fatal_reading_state (t0, "missing !fileslist in state file");
}


/* Read the trailer.  */
static void
read_state_trailer (void)
{
  struct state_token_st *t0 = peek_state_token (0);
  struct state_token_st *t1 = peek_state_token (1);
  struct state_token_st *t2 = peek_state_token (2);

  if (state_token_kind (t0) == STOK_LEFTPAR
      && state_token_is_name (t1, "!endfile")
      && state_token_kind (t2) == STOK_RIGHTPAR)
    next_state_tokens (3);
  else
    fatal_reading_state (t0, "missing !endfile in state file");
}


/* Utility functions for the state_seen_types hash table.  */
static unsigned
hash_type_number (const void *ty)
{
  const struct type *type = (const struct type *) ty;

  return type->state_number;
}

static int
equals_type_number (const void *ty1, const void *ty2)
{
  const struct type *type1 = (const struct type *) ty1;
  const struct type *type2 = (const struct type *) ty2;

  return type1->state_number == type2->state_number;
}

static int
string_eq (const void *a, const void *b)
{
  const char *a0 = (const char *)a;
  const char *b0 = (const char *)b;

  return (strcmp (a0, b0) == 0);
}


/* The function reading the state, called by main from gengtype.c.  */
void
read_state (const char *path)
{
  state_file = fopen (path, "r");
  if (state_file == NULL)
    fatal ("Failed to open state file %s for reading [%s]", path,
           xstrerror (errno));
  state_path = path;
  state_line = 1;

  if (verbosity_level >= 1)
    {
      printf ("%s reading state file %s;", progname, state_path);
      if (verbosity_level >= 2)
        putchar ('\n');
      fflush (stdout);
    }

  state_seen_types =
    htab_create (2017, hash_type_number, equals_type_number, NULL);
  state_ident_tab =
    htab_create (4027, htab_hash_string, string_eq, NULL);
  read_state_version (version_string);
  read_state_srcdir ();
  read_state_languages ();
  read_state_files_list ();
  read_state_structures (&structures);
  if (ferror (state_file))
    fatal_reading_state_printf
      (NULL_STATE_TOKEN, "input error while reading state [%s]",
       xstrerror (errno));
  read_state_typedefs (&typedefs);
  read_state_param_structs (&param_structs);
  read_state_variables (&variables);
  read_state_trailer ();

  if (verbosity_level >= 1)
    {
      printf ("%s read %ld bytes.\n", progname, ftell (state_file));
      fflush (stdout);
    };

  if (fclose (state_file))
    fatal ("failed to close read state file %s [%s]",
           path, xstrerror (errno));
  state_file = NULL;
  state_path = NULL;
}

/* End of file gengtype-state.c.  */