Release FreeBSD 1.1upstream/1.1.0_cvsrelease/1.1.0_cvs

This commit was manufactured to restore the state of the 1.1-RELEASE image.
Releases prior to 5.3-RELEASE are omitting the secure/ and crypto/ subdirs.

10 files changed, 19548 insertions, 0 deletions

diff --git a/gnu/usr.bin/cc/cc1/Makefile b/gnu/usr.bin/cc/cc1/Makefile
new file mode 100644
index 000000000000..6e26b5140699
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/Makefile
@@ -0,0 +1,23 @@
+#	@(#)Makefile	6.2 (Berkeley) 2/2/91
+
+PROG=		gcc1
+BINDIR=		/usr/libexec
+SRCS=		c-parse.c c-lang.c  c-lex.c c-pragma.c c-decl.c \
+		c-typeck.c c-convert.c c-aux-info.c c-iterate.c 
+	
+CFLAGS+=	-I. -I$(.CURDIR) -I$(.CURDIR)/../lib
+YFLAGS=
+NOMAN=		noman
+
+.if exists(${.CURDIR}/../lib/obj)
+LDADD=	-L${.CURDIR}/../lib/obj -lgcc2
+DPADD=	${.CURDIR}/../lib/obj/libgcc2.a
+.else
+LDADD=	-L${.CURDIR}/../lib/ -lgcc2
+DPADD=	${.CURDIR}/../lib/libgcc2.a
+.endif
+
+LDADD+=	-lgnumalloc
+DPADD+=	${LIBGNUMALLOC}
+
+.include <bsd.prog.mk>
diff --git a/gnu/usr.bin/cc/cc1/c-aux-info.c b/gnu/usr.bin/cc/cc1/c-aux-info.c
new file mode 100644
index 000000000000..2e1506447e35
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-aux-info.c
@@ -0,0 +1,642 @@
+/* Generate information regarding function declarations and definitions based
+   on information stored in GCC's tree structure.  This code implements the
+   -aux-info option.
+
+   This code was written by Ron Guilmette (rfg@mcc.com).
+
+   Copyright (C) 1989, 1991 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <stdio.h>
+#include "config.h"
+#include "flags.h"
+#include "tree.h"
+#include "c-tree.h"
+
+extern char* xmalloc ();
+
+enum formals_style_enum {
+  ansi,
+  k_and_r_names,
+  k_and_r_decls
+};
+typedef enum formals_style_enum formals_style;
+
+
+static char* data_type;
+
+static char * concat ();
+static char * concat3 ();
+static char * gen_formal_list_for_type ();
+static int    deserves_ellipsis ();
+static char * gen_formal_list_for_func_def ();
+static char * gen_type ();
+static char * gen_decl ();
+void   gen_aux_info_record ();
+
+/*  Take two strings and mash them together into a newly allocated area.  */
+
+static char*
+concat (s1, s2)
+     char* s1;
+     char* s2;
+{
+  int size1, size2;
+  char* ret_val;
+
+  if (!s1)
+    s1 = "";
+  if (!s2)
+    s2 = "";
+
+  size1 = strlen (s1);
+  size2 = strlen (s2);
+  ret_val = xmalloc (size1 + size2 + 1);
+  strcpy (ret_val, s1);
+  strcpy (&ret_val[size1], s2);
+  return ret_val;
+}
+
+/*  Take three strings and mash them together into a newly allocated area.  */
+
+static char*
+concat3 (s1, s2, s3)
+     char* s1;
+     char* s2;
+     char* s3;
+{
+  int size1, size2, size3;
+  char* ret_val;
+
+  if (!s1)
+    s1 = "";
+  if (!s2)
+    s2 = "";
+  if (!s3)
+    s3 = "";
+
+  size1 = strlen (s1);
+  size2 = strlen (s2);
+  size3 = strlen (s3);
+  ret_val = xmalloc (size1 + size2 + size3 + 1);
+  strcpy (ret_val, s1);
+  strcpy (&ret_val[size1], s2);
+  strcpy (&ret_val[size1+size2], s3);
+  return ret_val;
+}
+
+/* Given a string representing an entire type or an entire declaration
+   which only lacks the actual "data-type" specifier (at its left end),
+   affix the data-type specifier to the left end of the given type
+   specification or object declaration.
+
+   Because of C language weirdness, the data-type specifier (which normally
+   goes in at the very left end) may have to be slipped in just to the
+   right of any leading "const" or "volatile" qualifiers (there may be more
+   than one).  Actually this may not be strictly necessary because it seems
+   that GCC (at least) accepts `<data-type> const foo;' and treats it the
+   same as `const <data-type> foo;' but people are accustomed to seeing
+   `const char *foo;' and *not* `char const *foo;' so we try to create types
+   that look as expected.  */
+
+static char*
+affix_data_type (type_or_decl)
+     char *type_or_decl;
+{
+  char *p = type_or_decl;
+  char *qualifiers_then_data_type;
+  char saved;
+
+  /* Skip as many leading const's or volatile's as there are.  */
+
+  for (;;)
+    {
+      if (!strncmp (p, "volatile ", 9))
+        {
+          p += 9;
+          continue;
+        }
+      if (!strncmp (p, "const ", 6))
+        {
+          p += 6;
+          continue;
+        }
+      break;
+    }
+
+  /* p now points to the place where we can insert the data type.  We have to
+     add a blank after the data-type of course.  */
+
+  if (p == type_or_decl)
+    return concat3 (data_type, " ", type_or_decl);
+
+  saved = *p;
+  *p = '\0';
+  qualifiers_then_data_type = concat (type_or_decl, data_type);
+  *p = saved;
+  return concat3 (qualifiers_then_data_type, " ", p);
+}
+
+/* Given a tree node which represents some "function type", generate the
+   source code version of a formal parameter list (of some given style) for
+   this function type.  Return the whole formal parameter list (including
+   a pair of surrounding parens) as a string.   Note that if the style
+   we are currently aiming for is non-ansi, then we just return a pair
+   of empty parens here. */
+
+static char*
+gen_formal_list_for_type (fntype, style)
+     tree fntype;
+     formals_style style;
+{
+  char* formal_list = "";
+  tree formal_type;
+
+  if (style != ansi)
+    return "()";
+
+  formal_type = TYPE_ARG_TYPES (fntype);
+  while (formal_type && TREE_VALUE (formal_type) != void_type_node)
+    {
+      char* this_type;
+
+      if (*formal_list)
+        formal_list = concat (formal_list, ", ");
+
+      this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
+      formal_list =
+          (strlen (this_type))
+              ? concat (formal_list, affix_data_type (this_type))
+              : concat (formal_list, data_type);
+
+      formal_type = TREE_CHAIN (formal_type);
+    }
+
+  /* If we got to here, then we are trying to generate an ANSI style formal
+     parameters list.
+
+     New style prototyped ANSI formal parameter lists should in theory always
+     contain some stuff between the opening and closing parens, even if it is
+     only "void".
+
+     The brutal truth though is that there is lots of old K&R code out there
+     which contains declarations of "pointer-to-function" parameters and
+     these almost never have fully specified formal parameter lists associated
+     with them.  That is, the pointer-to-function parameters are declared
+     with just empty parameter lists.
+
+     In cases such as these, protoize should really insert *something* into
+     the vacant parameter lists, but what?  It has no basis on which to insert
+     anything in particular.
+
+     Here, we make life easy for protoize by trying to distinguish between
+     K&R empty parameter lists and new-style prototyped parameter lists
+     that actually contain "void".  In the latter case we (obviously) want
+     to output the "void" verbatim, and that what we do.  In the former case,
+     we do our best to give protoize something nice to insert.
+
+     This "something nice" should be something that is still legal (when
+     re-compiled) but something that can clearly indicate to the user that
+     more typing information (for the parameter list) should be added (by
+     hand) at some convenient moment.
+
+     The string chosen here is a comment with question marks in it.  */
+
+  if (!*formal_list)
+    {
+      if (TYPE_ARG_TYPES (fntype))
+        /* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node);  */
+        formal_list = "void";
+      else
+        formal_list = "/* ??? */";
+    }
+  else
+    {
+      /* If there were at least some parameters, and if the formals-types-list
+         petered out to a NULL (i.e. without being terminated by a
+         void_type_node) then we need to tack on an ellipsis.  */
+      if (!formal_type)
+        formal_list = concat (formal_list, ", ...");
+    }
+
+  return concat3 (" (", formal_list, ")");
+}
+
+/* For the generation of an ANSI prototype for a function definition, we have
+   to look at the formal parameter list of the function's own "type" to
+   determine if the function's formal parameter list should end with an
+   ellipsis.  Given a tree node, the following function will return non-zero
+   if the "function type" parameter list should end with an ellipsis.  */
+
+static int
+deserves_ellipsis (fntype)
+     tree fntype;
+{
+  tree formal_type;
+
+  formal_type = TYPE_ARG_TYPES (fntype);
+  while (formal_type && TREE_VALUE (formal_type) != void_type_node)
+    formal_type = TREE_CHAIN (formal_type);
+
+  /* If there were at least some parameters, and if the formals-types-list
+     petered out to a NULL (i.e. without being terminated by a void_type_node)
+     then we need to tack on an ellipsis.  */
+
+  return (!formal_type && TYPE_ARG_TYPES (fntype));
+}
+
+/* Generate a parameter list for a function definition (in some given style).
+
+   Note that this routine has to be separate (and different) from the code that
+   generates the prototype parameter lists for function declarations, because
+   in the case of a function declaration, all we have to go on is a tree node
+   representing the function's own "function type".  This can tell us the types
+   of all of the formal parameters for the function, but it cannot tell us the
+   actual *names* of each of the formal parameters.  We need to output those
+   parameter names for each function definition.
+
+   This routine gets a pointer to a tree node which represents the actual
+   declaration of the given function, and this DECL node has a list of formal
+   parameter (variable) declarations attached to it.  These formal parameter
+   (variable) declaration nodes give us the actual names of the formal
+   parameters for the given function definition.
+
+   This routine returns a string which is the source form for the entire
+   function formal parameter list.  */
+
+static char*
+gen_formal_list_for_func_def (fndecl, style)
+     tree fndecl;
+     formals_style style;
+{
+  char* formal_list = "";
+  tree formal_decl;
+
+  formal_decl = DECL_ARGUMENTS (fndecl);
+  while (formal_decl)
+    {
+      char *this_formal;
+
+      if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
+        formal_list = concat (formal_list, ", ");
+      this_formal = gen_decl (formal_decl, 0, style);
+      if (style == k_and_r_decls)
+        formal_list = concat3 (formal_list, this_formal, "; ");
+      else
+        formal_list = concat (formal_list, this_formal);
+      formal_decl = TREE_CHAIN (formal_decl);
+    }
+  if (style == ansi)
+    {
+      if (!DECL_ARGUMENTS (fndecl))
+        formal_list = concat (formal_list, "void");
+      if (deserves_ellipsis (TREE_TYPE (fndecl)))
+        formal_list = concat (formal_list, ", ...");
+    }
+  if ((style == ansi) || (style == k_and_r_names))
+    formal_list = concat3 (" (", formal_list, ")");
+  return formal_list;
+}
+
+/* Generate a string which is the source code form for a given type (t).  This
+   routine is ugly and complex because the C syntax for declarations is ugly
+   and complex.  This routine is straightforward so long as *no* pointer types,
+   array types, or function types are involved.
+
+   In the simple cases, this routine will return the (string) value which was
+   passed in as the "ret_val" argument.  Usually, this starts out either as an
+   empty string, or as the name of the declared item (i.e. the formal function
+   parameter variable).
+
+   This routine will also return with the global variable "data_type" set to
+   some string value which is the "basic" data-type of the given complete type.
+   This "data_type" string can be concatenated onto the front of the returned
+   string after this routine returns to its caller.
+
+   In complicated cases involving pointer types, array types, or function
+   types, the C declaration syntax requires an "inside out" approach, i.e. if
+   you have a type which is a "pointer-to-function" type, you need to handle
+   the "pointer" part first, but it also has to be "innermost" (relative to
+   the declaration stuff for the "function" type).  Thus, is this case, you
+   must prepend a "(*" and append a ")" to the name of the item (i.e. formal
+   variable).  Then you must append and prepend the other info for the
+   "function type" part of the overall type.
+
+   To handle the "innermost precedence" rules of complicated C declarators, we
+   do the following (in this routine).  The input parameter called "ret_val"
+   is treated as a "seed".  Each time gen_type is called (perhaps recursively)
+   some additional strings may be appended or prepended (or both) to the "seed"
+   string.  If yet another (lower) level of the GCC tree exists for the given
+   type (as in the case of a pointer type, an array type, or a function type)
+   then the (wrapped) seed is passed to a (recursive) invocation of gen_type()
+   this recursive invocation may again "wrap" the (new) seed with yet more
+   declarator stuff, by appending, prepending (or both).  By the time the
+   recursion bottoms out, the "seed value" at that point will have a value
+   which is (almost) the complete source version of the declarator (except
+   for the data_type info).  Thus, this deepest "seed" value is simply passed
+   back up through all of the recursive calls until it is given (as the return
+   value) to the initial caller of the gen_type() routine.  All that remains
+   to do at this point is for the initial caller to prepend the "data_type"
+   string onto the returned "seed".  */
+
+static char*
+gen_type (ret_val, t, style)
+     char* ret_val;
+     tree t;
+     formals_style style;
+{
+  tree chain_p;
+
+  if (TYPE_NAME (t) && DECL_NAME (TYPE_NAME (t)))
+    data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
+  else
+    {
+      switch (TREE_CODE (t))
+        {
+        case POINTER_TYPE:
+          if (TYPE_READONLY (t))
+            ret_val = concat ("const ", ret_val);
+          if (TYPE_VOLATILE (t))
+            ret_val = concat ("volatile ", ret_val);
+
+          ret_val = concat ("*", ret_val);
+
+	  if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
+	    ret_val = concat3 ("(", ret_val, ")");
+
+          ret_val = gen_type (ret_val, TREE_TYPE (t), style);
+
+          return ret_val;
+
+        case ARRAY_TYPE:
+	  if (TYPE_SIZE (t) == 0 || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
+	    ret_val = gen_type (concat (ret_val, "[]"), TREE_TYPE (t), style);
+	  else if (int_size_in_bytes (t) == 0)
+	    ret_val = gen_type (concat (ret_val, "[0]"), TREE_TYPE (t), style);
+	  else
+	    {
+	      int size = (int_size_in_bytes (t) / int_size_in_bytes (TREE_TYPE (t)));
+	      char buff[10];
+	      sprintf (buff, "[%d]", size);
+	      ret_val = gen_type (concat (ret_val, buff),
+				  TREE_TYPE (t), style);
+	    }
+          break;
+
+        case FUNCTION_TYPE:
+          ret_val = gen_type (concat (ret_val, gen_formal_list_for_type (t, style)), TREE_TYPE (t), style);
+          break;
+
+        case IDENTIFIER_NODE:
+          data_type = IDENTIFIER_POINTER (t);
+          break;
+
+	/* The following three cases are complicated by the fact that a
+           user may do something really stupid, like creating a brand new
+           "anonymous" type specification in a formal argument list (or as
+           part of a function return type specification).  For example:
+
+		int f (enum { red, green, blue } color);
+
+	   In such cases, we have no name that we can put into the prototype
+	   to represent the (anonymous) type.  Thus, we have to generate the
+	   whole darn type specification.  Yuck!  */
+
+        case RECORD_TYPE:
+	  if (TYPE_NAME (t))
+	    data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
+	  else
+	    {
+	      data_type = "";
+	      chain_p = TYPE_FIELDS (t);
+	      while (chain_p)
+		{
+		  data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
+		  chain_p = TREE_CHAIN (chain_p);
+		  data_type = concat (data_type, "; ");
+		}
+	      data_type = concat3 ("{ ", data_type, "}");
+	    }
+	  data_type = concat ("struct ", data_type);
+	  break;
+
+        case UNION_TYPE:
+	  if (TYPE_NAME (t))
+	    data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
+	  else
+	    {
+	      data_type = "";
+	      chain_p = TYPE_FIELDS (t);
+	      while (chain_p)
+		{
+		  data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
+		  chain_p = TREE_CHAIN (chain_p);
+		  data_type = concat (data_type, "; ");
+		}
+	      data_type = concat3 ("{ ", data_type, "}");
+	    }
+	  data_type = concat ("union ", data_type);
+	  break;
+
+        case ENUMERAL_TYPE:
+	  if (TYPE_NAME (t))
+	    data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
+	  else
+	    {
+	      data_type = "";
+	      chain_p = TYPE_VALUES (t);
+	      while (chain_p)
+		{
+		  data_type = concat (data_type,
+			IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)));
+		  chain_p = TREE_CHAIN (chain_p);
+		  if (chain_p)
+		    data_type = concat (data_type, ", ");
+		}
+	      data_type = concat3 ("{ ", data_type, " }");
+	    }
+	  data_type = concat ("enum ", data_type);
+	  break;
+
+        case TYPE_DECL:
+          data_type = IDENTIFIER_POINTER (DECL_NAME (t));
+          break;
+ 
+        case INTEGER_TYPE:
+          data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
+          /* Normally, `unsigned' is part of the deal.  Not so if it comes
+    	     with `const' or `volatile'.  */
+          if (TREE_UNSIGNED (t) && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
+    	    data_type = concat ("unsigned ", data_type);
+	  break;
+
+        case REAL_TYPE:
+          data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
+          break;
+
+        case VOID_TYPE:
+          data_type = "void";
+          break;
+
+        default:
+          abort ();
+        }
+    }
+  if (TYPE_READONLY (t))
+    ret_val = concat ("const ", ret_val);
+  if (TYPE_VOLATILE (t))
+    ret_val = concat ("volatile ", ret_val);
+  return ret_val;
+}
+
+/* Generate a string (source) representation of an entire entity declaration
+   (using some particular style for function types).
+
+   The given entity may be either a variable or a function.
+
+   If the "is_func_definition" parameter is non-zero, assume that the thing
+   we are generating a declaration for is a FUNCTION_DECL node which is
+   associated with a function definition.  In this case, we can assume that
+   an attached list of DECL nodes for function formal arguments is present.  */
+
+static char*
+gen_decl (decl, is_func_definition, style)
+     tree decl;
+     int is_func_definition;
+     formals_style style;
+{
+  char* ret_val;
+  char* outer_modifier = "";
+
+  if (DECL_NAME (decl))
+    ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
+  else
+    ret_val = "";
+
+  /* If we are just generating a list of names of formal parameters, we can
+     simply return the formal parameter name (with no typing information
+     attached to it) now.  */
+
+  if (style == k_and_r_names)
+    return ret_val;
+
+  /* Note that for the declaration of some entity (either a function or a
+     data object, like for instance a parameter) if the entity itself was
+     declared as either const or volatile, then const and volatile properties
+     are associated with just the declaration of the entity, and *not* with
+     the `type' of the entity.  Thus, for such declared entities, we have to
+     generate the qualifiers here.  */
+
+  if (TREE_THIS_VOLATILE (decl))
+    ret_val = concat ("volatile ", ret_val);
+  if (TREE_READONLY (decl))
+    ret_val = concat ("const ", ret_val);
+
+  data_type = "";
+
+  /* For FUNCTION_DECL nodes, there are two possible cases here.  First, if
+     this FUNCTION_DECL node was generated from a function "definition", then
+     we will have a list of DECL_NODE's, one for each of the function's formal
+     parameters.  In this case, we can print out not only the types of each
+     formal, but also each formal's name.  In the second case, this
+     FUNCTION_DECL node came from an actual function declaration (and *not*
+     a definition).  In this case, we do nothing here because the formal
+     argument type-list will be output later, when the "type" of the function
+     is added to the string we are building.  Note that the ANSI-style formal
+     parameter list is considered to be a (suffix) part of the "type" of the
+     function.  */
+
+  if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
+    {
+      ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi));
+
+      /* Since we have already added in the formals list stuff, here we don't
+         add the whole "type" of the function we are considering (which
+         would include its parameter-list info), rather, we only add in
+         the "type" of the "type" of the function, which is really just
+         the return-type of the function (and does not include the parameter
+         list info).  */
+
+      ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
+    }
+  else
+    ret_val = gen_type (ret_val, TREE_TYPE (decl), style);
+
+  ret_val = affix_data_type (ret_val);
+
+  if (DECL_REGISTER (decl))
+    ret_val = concat ("register ", ret_val);
+  if (TREE_PUBLIC (decl))
+    ret_val = concat ("extern ", ret_val);
+  if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
+    ret_val = concat ("static ", ret_val);
+
+  return ret_val;
+}
+
+extern FILE* aux_info_file;
+
+/* Generate and write a new line of info to the aux-info (.X) file.  This
+   routine is called once for each function declaration, and once for each
+   function definition (even the implicit ones).  */
+
+void
+gen_aux_info_record (fndecl, is_definition, is_implicit, is_prototyped)
+     tree fndecl;
+     int is_definition;
+     int is_implicit;
+     int is_prototyped;
+{
+  if (flag_gen_aux_info)
+    {
+      static int compiled_from_record = 0;
+
+      /* Each output .X file must have a header line.  Write one now if we
+	 have not yet done so.  */
+
+      if (! compiled_from_record++)
+	{
+	  /* The first line tells which directory file names are relative to.
+	     Currently, -aux-info works only for files in the working
+	     directory, so just use a `.' as a placeholder for now.  */
+	  fprintf (aux_info_file, "/* compiled from: . */\n");
+	}
+
+      /* Write the actual line of auxiliary info.  */
+
+      fprintf (aux_info_file, "/* %s:%d:%c%c */ %s;",
+	       DECL_SOURCE_FILE (fndecl),
+	       DECL_SOURCE_LINE (fndecl),
+	       (is_implicit) ? 'I' : (is_prototyped) ? 'N' : 'O',
+	       (is_definition) ? 'F' : 'C',
+	       gen_decl (fndecl, is_definition, ansi));
+
+      /* If this is an explicit function declaration, we need to also write
+	 out an old-style (i.e. K&R) function header, just in case the user
+	 wants to run unprotoize.  */
+
+      if (is_definition)
+	{
+	  fprintf (aux_info_file, " /*%s %s*/",
+		   gen_formal_list_for_func_def (fndecl, k_and_r_names),
+		   gen_formal_list_for_func_def (fndecl, k_and_r_decls));
+	}
+
+      fprintf (aux_info_file, "\n");
+    }
+}
diff --git a/gnu/usr.bin/cc/cc1/c-convert.c b/gnu/usr.bin/cc/cc1/c-convert.c
new file mode 100644
index 000000000000..cfa590cfa6c2
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-convert.c
@@ -0,0 +1,95 @@
+/* Language-level data type conversion for GNU C.
+   Copyright (C) 1987, 1988, 1991 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* This file contains the functions for converting C expressions
+   to different data types.  The only entry point is `convert'.
+   Every language front end must have a `convert' function
+   but what kind of conversions it does will depend on the language.  */
+
+#include "config.h"
+#include "tree.h"
+#include "flags.h"
+#include "convert.h"
+
+/* Change of width--truncation and extension of integers or reals--
+   is represented with NOP_EXPR.  Proper functioning of many things
+   assumes that no other conversions can be NOP_EXPRs.
+
+   Conversion between integer and pointer is represented with CONVERT_EXPR.
+   Converting integer to real uses FLOAT_EXPR
+   and real to integer uses FIX_TRUNC_EXPR.
+
+   Here is a list of all the functions that assume that widening and
+   narrowing is always done with a NOP_EXPR:
+     In convert.c, convert_to_integer.
+     In c-typeck.c, build_binary_op (boolean ops), and truthvalue_conversion.
+     In expr.c: expand_expr, for operands of a MULT_EXPR.
+     In fold-const.c: fold.
+     In tree.c: get_narrower and get_unwidened.  */
+
+/* Subroutines of `convert'.  */
+
+
+
+/* Create an expression whose value is that of EXPR,
+   converted to type TYPE.  The TREE_TYPE of the value
+   is always TYPE.  This function implements all reasonable
+   conversions; callers should filter out those that are
+   not permitted by the language being compiled.  */
+
+tree
+convert (type, expr)
+     tree type, expr;
+{
+  register tree e = expr;
+  register enum tree_code code = TREE_CODE (type);
+
+  if (type == TREE_TYPE (expr)
+      || TREE_CODE (expr) == ERROR_MARK)
+    return expr;
+  if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
+    return fold (build1 (NOP_EXPR, type, expr));
+  if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
+    return error_mark_node;
+  if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
+    {
+      error ("void value not ignored as it ought to be");
+      return error_mark_node;
+    }
+  if (code == VOID_TYPE)
+    return build1 (CONVERT_EXPR, type, e);
+#if 0
+  /* This is incorrect.  A truncation can't be stripped this way.
+     Extensions will be stripped by the use of get_unwidened.  */
+  if (TREE_CODE (expr) == NOP_EXPR)
+    return convert (type, TREE_OPERAND (expr, 0));
+#endif
+  if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
+    return fold (convert_to_integer (type, e));
+  if (code == POINTER_TYPE)
+    return fold (convert_to_pointer (type, e));
+  if (code == REAL_TYPE)
+    return fold (convert_to_real (type, e));
+  if (code == COMPLEX_TYPE)
+    return fold (convert_to_complex (type, e));
+
+  error ("conversion to non-scalar type requested");
+  return error_mark_node;
+}
diff --git a/gnu/usr.bin/cc/cc1/c-decl.c b/gnu/usr.bin/cc/cc1/c-decl.c
new file mode 100644
index 000000000000..08f003e1f0e5
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-decl.c
@@ -0,0 +1,6494 @@
+/* Process declarations and variables for C compiler.
+   Copyright (C) 1988, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* Process declarations and symbol lookup for C front end.
+   Also constructs types; the standard scalar types at initialization,
+   and structure, union, array and enum types when they are declared.  */
+
+/* ??? not all decl nodes are given the most useful possible
+   line numbers.  For example, the CONST_DECLs for enum values.  */
+
+#include "config.h"
+#include "tree.h"
+#include "flags.h"
+#include "c-tree.h"
+#include "c-lex.h"
+#include <stdio.h>
+
+/* In grokdeclarator, distinguish syntactic contexts of declarators.  */
+enum decl_context
+{ NORMAL,			/* Ordinary declaration */
+  FUNCDEF,			/* Function definition */
+  PARM,				/* Declaration of parm before function body */
+  FIELD,			/* Declaration inside struct or union */
+  BITFIELD,			/* Likewise but with specified width */
+  TYPENAME};			/* Typename (inside cast or sizeof)  */
+
+#ifndef CHAR_TYPE_SIZE
+#define CHAR_TYPE_SIZE BITS_PER_UNIT
+#endif
+
+#ifndef SHORT_TYPE_SIZE
+#define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
+#endif
+
+#ifndef INT_TYPE_SIZE
+#define INT_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef LONG_TYPE_SIZE
+#define LONG_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef LONG_LONG_TYPE_SIZE
+#define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
+#endif
+
+#ifndef WCHAR_UNSIGNED
+#define WCHAR_UNSIGNED 0
+#endif
+
+#ifndef FLOAT_TYPE_SIZE
+#define FLOAT_TYPE_SIZE BITS_PER_WORD
+#endif
+
+#ifndef DOUBLE_TYPE_SIZE
+#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
+#endif
+
+#ifndef LONG_DOUBLE_TYPE_SIZE
+#define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
+#endif
+
+/* We let tm.h override the types used here, to handle trivial differences
+   such as the choice of unsigned int or long unsigned int for size_t.
+   When machines start needing nontrivial differences in the size type,
+   it would be best to do something here to figure out automatically
+   from other information what type to use.  */
+
+#ifndef SIZE_TYPE
+#define SIZE_TYPE "long unsigned int"
+#endif
+
+#ifndef PTRDIFF_TYPE
+#define PTRDIFF_TYPE "long int"
+#endif
+
+#ifndef WCHAR_TYPE
+#define WCHAR_TYPE "int"
+#endif
+
+/* a node which has tree code ERROR_MARK, and whose type is itself.
+   All erroneous expressions are replaced with this node.  All functions
+   that accept nodes as arguments should avoid generating error messages
+   if this node is one of the arguments, since it is undesirable to get
+   multiple error messages from one error in the input.  */
+
+tree error_mark_node;
+
+/* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
+
+tree short_integer_type_node;
+tree integer_type_node;
+tree long_integer_type_node;
+tree long_long_integer_type_node;
+
+tree short_unsigned_type_node;
+tree unsigned_type_node;
+tree long_unsigned_type_node;
+tree long_long_unsigned_type_node;
+
+tree ptrdiff_type_node;
+
+tree unsigned_char_type_node;
+tree signed_char_type_node;
+tree char_type_node;
+tree wchar_type_node;
+tree signed_wchar_type_node;
+tree unsigned_wchar_type_node;
+
+tree float_type_node;
+tree double_type_node;
+tree long_double_type_node;
+
+tree complex_integer_type_node;
+tree complex_float_type_node;
+tree complex_double_type_node;
+tree complex_long_double_type_node;
+
+tree intQI_type_node;
+tree intHI_type_node;
+tree intSI_type_node;
+tree intDI_type_node;
+
+tree unsigned_intQI_type_node;
+tree unsigned_intHI_type_node;
+tree unsigned_intSI_type_node;
+tree unsigned_intDI_type_node;
+
+/* a VOID_TYPE node.  */
+
+tree void_type_node;
+
+/* Nodes for types `void *' and `const void *'.  */
+
+tree ptr_type_node, const_ptr_type_node;
+
+/* Nodes for types `char *' and `const char *'.  */
+
+tree string_type_node, const_string_type_node;
+
+/* Type `char[SOMENUMBER]'.
+   Used when an array of char is needed and the size is irrelevant.  */
+
+tree char_array_type_node;
+
+/* Type `int[SOMENUMBER]' or something like it.
+   Used when an array of int needed and the size is irrelevant.  */
+
+tree int_array_type_node;
+
+/* Type `wchar_t[SOMENUMBER]' or something like it.
+   Used when a wide string literal is created.  */
+
+tree wchar_array_type_node;
+
+/* type `int ()' -- used for implicit declaration of functions.  */
+
+tree default_function_type;
+
+/* function types `double (double)' and `double (double, double)', etc.  */
+
+tree double_ftype_double, double_ftype_double_double;
+tree int_ftype_int, long_ftype_long;
+
+/* Function type `void (void *, void *, int)' and similar ones */
+
+tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
+
+/* Function type `char *(char *, char *)' and similar ones */
+tree string_ftype_ptr_ptr, int_ftype_string_string;
+
+/* Function type `int (const void *, const void *, size_t)' */
+tree int_ftype_cptr_cptr_sizet;
+
+/* Two expressions that are constants with value zero.
+   The first is of type `int', the second of type `void *'.  */
+
+tree integer_zero_node;
+tree null_pointer_node;
+
+/* A node for the integer constant 1.  */
+
+tree integer_one_node;
+
+/* Nonzero if we have seen an invalid cross reference
+   to a struct, union, or enum, but not yet printed the message.  */
+
+tree pending_invalid_xref;
+/* File and line to appear in the eventual error message.  */
+char *pending_invalid_xref_file;
+int pending_invalid_xref_line;
+
+/* While defining an enum type, this is 1 plus the last enumerator
+   constant value.  */
+
+static tree enum_next_value;
+
+/* Nonzero means that there was overflow computing enum_next_value.  */
+
+static int enum_overflow;
+
+/* Parsing a function declarator leaves a list of parameter names
+   or a chain or parameter decls here.  */
+
+static tree last_function_parms;
+
+/* Parsing a function declarator leaves here a chain of structure
+   and enum types declared in the parmlist.  */
+
+static tree last_function_parm_tags;
+
+/* After parsing the declarator that starts a function definition,
+   `start_function' puts here the list of parameter names or chain of decls.
+   `store_parm_decls' finds it here.  */
+
+static tree current_function_parms;
+
+/* Similar, for last_function_parm_tags.  */
+static tree current_function_parm_tags;
+
+/* Similar, for the file and line that the prototype came from if this is
+   an old-style definition.  */
+static char *current_function_prototype_file;
+static int current_function_prototype_line;
+
+/* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
+   that have names.  Here so we can clear out their names' definitions
+   at the end of the function.  */
+
+static tree named_labels;
+
+/* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
+
+static tree shadowed_labels;
+
+/* Nonzero when store_parm_decls is called indicates a varargs function.
+   Value not meaningful after store_parm_decls.  */
+
+static int c_function_varargs;
+
+/* The FUNCTION_DECL for the function currently being compiled,
+   or 0 if between functions.  */
+tree current_function_decl;
+
+/* Set to 0 at beginning of a function definition, set to 1 if
+   a return statement that specifies a return value is seen.  */
+
+int current_function_returns_value;
+
+/* Set to 0 at beginning of a function definition, set to 1 if
+   a return statement with no argument is seen.  */
+
+int current_function_returns_null;
+
+/* Set to nonzero by `grokdeclarator' for a function
+   whose return type is defaulted, if warnings for this are desired.  */
+
+static int warn_about_return_type;
+
+/* Nonzero when starting a function declared `extern inline'.  */
+
+static int current_extern_inline;
+
+/* For each binding contour we allocate a binding_level structure
+ * which records the names defined in that contour.
+ * Contours include:
+ *  0) the global one
+ *  1) one for each function definition,
+ *     where internal declarations of the parameters appear.
+ *  2) one for each compound statement,
+ *     to record its declarations.
+ *
+ * The current meaning of a name can be found by searching the levels from
+ * the current one out to the global one.
+ */
+
+/* Note that the information in the `names' component of the global contour
+   is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
+
+struct binding_level
+  {
+    /* A chain of _DECL nodes for all variables, constants, functions,
+       and typedef types.  These are in the reverse of the order supplied.
+     */
+    tree names;
+
+    /* A list of structure, union and enum definitions,
+     * for looking up tag names.
+     * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
+     * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
+     * or ENUMERAL_TYPE node.
+     */
+    tree tags;
+
+    /* For each level, a list of shadowed outer-level local definitions
+       to be restored when this level is popped.
+       Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
+       whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
+    tree shadowed;
+
+    /* For each level (except not the global one),
+       a chain of BLOCK nodes for all the levels
+       that were entered and exited one level down.  */
+    tree blocks;
+
+    /* The BLOCK node for this level, if one has been preallocated.
+       If 0, the BLOCK is allocated (if needed) when the level is popped.  */
+    tree this_block;
+
+    /* The binding level which this one is contained in (inherits from).  */
+    struct binding_level *level_chain;
+
+    /* Nonzero for the level that holds the parameters of a function.  */
+    char parm_flag;
+
+    /* Nonzero if this level "doesn't exist" for tags.  */
+    char tag_transparent;
+
+    /* Nonzero if sublevels of this level "don't exist" for tags.
+       This is set in the parm level of a function definition
+       while reading the function body, so that the outermost block
+       of the function body will be tag-transparent.  */
+    char subblocks_tag_transparent;
+
+    /* Nonzero means make a BLOCK for this level regardless of all else.  */
+    char keep;
+
+    /* Nonzero means make a BLOCK if this level has any subblocks.  */
+    char keep_if_subblocks;
+
+    /* Number of decls in `names' that have incomplete 
+       structure or union types.  */
+    int n_incomplete;
+
+    /* A list of decls giving the (reversed) specified order of parms,
+       not including any forward-decls in the parmlist.
+       This is so we can put the parms in proper order for assign_parms.  */
+    tree parm_order;
+  };
+
+#define NULL_BINDING_LEVEL (struct binding_level *) NULL
+  
+/* The binding level currently in effect.  */
+
+static struct binding_level *current_binding_level;
+
+/* A chain of binding_level structures awaiting reuse.  */
+
+static struct binding_level *free_binding_level;
+
+/* The outermost binding level, for names of file scope.
+   This is created when the compiler is started and exists
+   through the entire run.  */
+
+static struct binding_level *global_binding_level;
+
+/* Binding level structures are initialized by copying this one.  */
+
+static struct binding_level clear_binding_level
+  = {NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0};
+
+/* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
+
+static int keep_next_level_flag;
+
+/* Nonzero means make a BLOCK for the next level pushed
+   if it has subblocks.  */
+
+static int keep_next_if_subblocks;
+  
+/* The chain of outer levels of label scopes.
+   This uses the same data structure used for binding levels,
+   but it works differently: each link in the chain records
+   saved values of named_labels and shadowed_labels for
+   a label binding level outside the current one.  */
+
+static struct binding_level *label_level_chain;
+
+/* Forward declarations.  */
+
+static tree grokparms (), grokdeclarator ();
+tree pushdecl ();
+tree builtin_function ();
+void shadow_tag_warned ();
+
+static tree lookup_tag ();
+static tree lookup_tag_reverse ();
+tree lookup_name_current_level ();
+static char *redeclaration_error_message ();
+static void layout_array_type ();
+
+/* C-specific option variables.  */
+
+/* Nonzero means allow type mismatches in conditional expressions;
+   just make their values `void'.   */
+
+int flag_cond_mismatch;
+
+/* Nonzero means give `double' the same size as `float'.  */
+
+int flag_short_double;
+
+/* Nonzero means don't recognize the keyword `asm'.  */
+
+int flag_no_asm;
+
+/* Nonzero means don't recognize any builtin functions.  */
+
+int flag_no_builtin;
+
+/* Nonzero means don't recognize the non-ANSI builtin functions.
+   -ansi sets this.  */
+
+int flag_no_nonansi_builtin;
+
+/* Nonzero means do some things the same way PCC does.  */
+
+int flag_traditional;
+
+/* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
+
+int flag_signed_bitfields = 1;
+int explicit_flag_signed_bitfields = 0;
+
+/* Nonzero means handle `#ident' directives.  0 means ignore them.  */
+
+int flag_no_ident = 0;
+
+/* Nonzero means warn about implicit declarations.  */
+
+int warn_implicit;
+
+/* Nonzero means give string constants the type `const char *'
+   to get extra warnings from them.  These warnings will be too numerous
+   to be useful, except in thoroughly ANSIfied programs.  */
+
+int warn_write_strings;
+
+/* Nonzero means warn about pointer casts that can drop a type qualifier
+   from the pointer target type.  */
+
+int warn_cast_qual;
+
+/* Warn about traditional constructs whose meanings changed in ANSI C.  */
+
+int warn_traditional;
+
+/* Nonzero means warn about sizeof(function) or addition/subtraction
+   of function pointers.  */
+
+int warn_pointer_arith;
+
+/* Nonzero means warn for non-prototype function decls
+   or non-prototyped defs without previous prototype.  */
+
+int warn_strict_prototypes;
+
+/* Nonzero means warn for any global function def
+   without separate previous prototype decl.  */
+
+int warn_missing_prototypes;
+
+/* Nonzero means warn about multiple (redundant) decls for the same single
+   variable or function.  */
+
+int warn_redundant_decls = 0;
+
+/* Nonzero means warn about extern declarations of objects not at
+   file-scope level and about *all* declarations of functions (whether
+   extern or static) not at file-scope level.  Note that we exclude
+   implicit function declarations.  To get warnings about those, use
+   -Wimplicit.  */
+
+int warn_nested_externs = 0;
+
+/* Warn about *printf or *scanf format/argument anomalies. */
+
+int warn_format;
+
+/* Warn about a subscript that has type char.  */
+
+int warn_char_subscripts = 0;
+
+/* Warn if a type conversion is done that might have confusing results.  */
+
+int warn_conversion;
+
+/* Warn if adding () is suggested.  */
+
+int warn_parentheses;
+
+/* Warn if initializer is not completely bracketed.  */
+
+int warn_missing_braces;
+
+/* Nonzero means `$' can be in an identifier.
+   See cccp.c for reasons why this breaks some obscure ANSI C programs.  */
+
+#ifndef DOLLARS_IN_IDENTIFIERS
+#define DOLLARS_IN_IDENTIFIERS 1
+#endif
+int dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
+
+/* Decode the string P as a language-specific option for C.
+   Return 1 if it is recognized (and handle it);
+   return 0 if not recognized.  */
+   
+int
+c_decode_option (p)
+     char *p;
+{
+  if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
+    {
+      flag_traditional = 1;
+      flag_writable_strings = 1;
+#if DOLLARS_IN_IDENTIFIERS > 0
+      dollars_in_ident = 1;
+#endif
+    }
+  else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
+    {
+      flag_traditional = 0;
+      flag_writable_strings = 0;
+      dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
+    }
+  else if (!strcmp (p, "-fsigned-char"))
+    flag_signed_char = 1;
+  else if (!strcmp (p, "-funsigned-char"))
+    flag_signed_char = 0;
+  else if (!strcmp (p, "-fno-signed-char"))
+    flag_signed_char = 0;
+  else if (!strcmp (p, "-fno-unsigned-char"))
+    flag_signed_char = 1;
+  else if (!strcmp (p, "-fsigned-bitfields")
+	   || !strcmp (p, "-fno-unsigned-bitfields"))
+    {
+      flag_signed_bitfields = 1;
+      explicit_flag_signed_bitfields = 1;
+    }
+  else if (!strcmp (p, "-funsigned-bitfields")
+	   || !strcmp (p, "-fno-signed-bitfields"))
+    {
+      flag_signed_bitfields = 0;
+      explicit_flag_signed_bitfields = 1;
+    }
+  else if (!strcmp (p, "-fshort-enums"))
+    flag_short_enums = 1;
+  else if (!strcmp (p, "-fno-short-enums"))
+    flag_short_enums = 0;
+  else if (!strcmp (p, "-fcond-mismatch"))
+    flag_cond_mismatch = 1;
+  else if (!strcmp (p, "-fno-cond-mismatch"))
+    flag_cond_mismatch = 0;
+  else if (!strcmp (p, "-fshort-double"))
+    flag_short_double = 1;
+  else if (!strcmp (p, "-fno-short-double"))
+    flag_short_double = 0;
+  else if (!strcmp (p, "-fasm"))
+    flag_no_asm = 0;
+  else if (!strcmp (p, "-fno-asm"))
+    flag_no_asm = 1;
+  else if (!strcmp (p, "-fbuiltin"))
+    flag_no_builtin = 0;
+  else if (!strcmp (p, "-fno-builtin"))
+    flag_no_builtin = 1;
+  else if (!strcmp (p, "-fno-ident"))
+    flag_no_ident = 1;
+  else if (!strcmp (p, "-fident"))
+    flag_no_ident = 0;
+  else if (!strcmp (p, "-ansi"))
+    flag_no_asm = 1, flag_no_nonansi_builtin = 1, dollars_in_ident = 0;
+  else if (!strcmp (p, "-Wimplicit"))
+    warn_implicit = 1;
+  else if (!strcmp (p, "-Wno-implicit"))
+    warn_implicit = 0;
+  else if (!strcmp (p, "-Wwrite-strings"))
+    warn_write_strings = 1;
+  else if (!strcmp (p, "-Wno-write-strings"))
+    warn_write_strings = 0;
+  else if (!strcmp (p, "-Wcast-qual"))
+    warn_cast_qual = 1;
+  else if (!strcmp (p, "-Wno-cast-qual"))
+    warn_cast_qual = 0;
+  else if (!strcmp (p, "-Wpointer-arith"))
+    warn_pointer_arith = 1;
+  else if (!strcmp (p, "-Wno-pointer-arith"))
+    warn_pointer_arith = 0;
+  else if (!strcmp (p, "-Wstrict-prototypes"))
+    warn_strict_prototypes = 1;
+  else if (!strcmp (p, "-Wno-strict-prototypes"))
+    warn_strict_prototypes = 0;
+  else if (!strcmp (p, "-Wmissing-prototypes"))
+    warn_missing_prototypes = 1;
+  else if (!strcmp (p, "-Wno-missing-prototypes"))
+    warn_missing_prototypes = 0;
+  else if (!strcmp (p, "-Wredundant-decls"))
+    warn_redundant_decls = 1;
+  else if (!strcmp (p, "-Wno-redundant-decls"))
+    warn_redundant_decls = 0;
+  else if (!strcmp (p, "-Wnested-externs"))
+    warn_nested_externs = 1;
+  else if (!strcmp (p, "-Wno-nested-externs"))
+    warn_nested_externs = 0;
+  else if (!strcmp (p, "-Wtraditional"))
+    warn_traditional = 1;
+  else if (!strcmp (p, "-Wno-traditional"))
+    warn_traditional = 0;
+  else if (!strcmp (p, "-Wformat"))
+    warn_format = 1;
+  else if (!strcmp (p, "-Wno-format"))
+    warn_format = 0;
+  else if (!strcmp (p, "-Wchar-subscripts"))
+    warn_char_subscripts = 1;
+  else if (!strcmp (p, "-Wno-char-subscripts"))
+    warn_char_subscripts = 0;
+  else if (!strcmp (p, "-Wconversion"))
+    warn_conversion = 1;
+  else if (!strcmp (p, "-Wno-conversion"))
+    warn_conversion = 0;
+  else if (!strcmp (p, "-Wparentheses"))
+    warn_parentheses = 1;
+  else if (!strcmp (p, "-Wno-parentheses"))
+    warn_parentheses = 0;
+  else if (!strcmp (p, "-Wreturn-type"))
+    warn_return_type = 1;
+  else if (!strcmp (p, "-Wno-return-type"))
+    warn_return_type = 0;
+  else if (!strcmp (p, "-Wcomment"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wno-comment"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wcomments"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wno-comments"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wtrigraphs"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wno-trigraphs"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wimport"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wno-import"))
+    ; /* cpp handles this one.  */
+  else if (!strcmp (p, "-Wmissing-braces"))
+    warn_missing_braces = 1;
+  else if (!strcmp (p, "-Wno-missing-braces"))
+    warn_missing_braces = 0;
+  else if (!strcmp (p, "-Wall"))
+    {
+      extra_warnings = 1;
+      /* We save the value of warn_uninitialized, since if they put
+	 -Wuninitialized on the command line, we need to generate a
+	 warning about not using it without also specifying -O.  */
+      if (warn_uninitialized != 1)
+	warn_uninitialized = 2;
+      warn_implicit = 1;
+      warn_return_type = 1;
+      warn_unused = 1;
+      warn_switch = 1;
+      warn_format = 1;
+      warn_char_subscripts = 1;
+      warn_parentheses = 1;
+      warn_missing_braces = 1;
+    }
+  else
+    return 0;
+
+  return 1;
+}
+
+/* Hooks for print_node.  */
+
+void
+print_lang_decl ()
+{
+}
+
+void
+print_lang_type ()
+{
+}
+
+void
+print_lang_identifier (file, node, indent)
+     FILE *file;
+     tree node;
+     int indent;
+{
+  print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
+  print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
+  print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
+  print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
+  print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
+  print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
+}
+
+/* Hook called at end of compilation to assume 1 elt
+   for a top-level array decl that wasn't complete before.  */
+   
+void
+finish_incomplete_decl (decl)
+     tree decl;
+{
+  if (TREE_CODE (decl) == VAR_DECL && TREE_TYPE (decl) != error_mark_node)
+    {
+      tree type = TREE_TYPE (decl);
+      if (TREE_CODE (type) == ARRAY_TYPE
+	  && TYPE_DOMAIN (type) == 0
+	  && TREE_CODE (decl) != TYPE_DECL)
+	{
+	  complete_array_type (type, NULL_TREE, 1);
+
+	  layout_decl (decl, 0);
+	}
+    }
+}
+
+/* Create a new `struct binding_level'.  */
+
+static
+struct binding_level *
+make_binding_level ()
+{
+  /* NOSTRICT */
+  return (struct binding_level *) xmalloc (sizeof (struct binding_level));
+}
+
+/* Nonzero if we are currently in the global binding level.  */
+
+int
+global_bindings_p ()
+{
+  return current_binding_level == global_binding_level;
+}
+
+void
+keep_next_level ()
+{
+  keep_next_level_flag = 1;
+}
+
+/* Nonzero if the current level needs to have a BLOCK made.  */
+
+int
+kept_level_p ()
+{
+  return ((current_binding_level->keep_if_subblocks
+	   && current_binding_level->blocks != 0)
+	  || current_binding_level->keep
+	  || current_binding_level->names != 0
+	  || (current_binding_level->tags != 0
+	      && !current_binding_level->tag_transparent));
+}
+
+/* Identify this binding level as a level of parameters.
+   DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
+   But it turns out there is no way to pass the right value for
+   DEFINITION_FLAG, so we ignore it.  */
+
+void
+declare_parm_level (definition_flag)
+     int definition_flag;
+{
+  current_binding_level->parm_flag = 1;
+}
+
+/* Nonzero if currently making parm declarations.  */
+
+int
+in_parm_level_p ()
+{
+  return current_binding_level->parm_flag;
+}
+
+/* Enter a new binding level.
+   If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
+   not for that of tags.  */
+
+void
+pushlevel (tag_transparent)
+     int tag_transparent;
+{
+  register struct binding_level *newlevel = NULL_BINDING_LEVEL;
+
+  /* If this is the top level of a function,
+     just make sure that NAMED_LABELS is 0.  */
+
+  if (current_binding_level == global_binding_level)
+    {
+      named_labels = 0;
+    }
+
+  /* Reuse or create a struct for this binding level.  */
+
+  if (free_binding_level)
+    {
+      newlevel = free_binding_level;
+      free_binding_level = free_binding_level->level_chain;
+    }
+  else
+    {
+      newlevel = make_binding_level ();
+    }
+
+  /* Add this level to the front of the chain (stack) of levels that
+     are active.  */
+
+  *newlevel = clear_binding_level;
+  newlevel->tag_transparent
+    = (tag_transparent
+       || (current_binding_level
+	   ? current_binding_level->subblocks_tag_transparent
+	   : 0));
+  newlevel->level_chain = current_binding_level;
+  current_binding_level = newlevel;
+  newlevel->keep = keep_next_level_flag;
+  keep_next_level_flag = 0;
+  newlevel->keep_if_subblocks = keep_next_if_subblocks;
+  keep_next_if_subblocks = 0;
+}
+
+/* Exit a binding level.
+   Pop the level off, and restore the state of the identifier-decl mappings
+   that were in effect when this level was entered.
+
+   If KEEP is nonzero, this level had explicit declarations, so
+   and create a "block" (a BLOCK node) for the level
+   to record its declarations and subblocks for symbol table output.
+
+   If FUNCTIONBODY is nonzero, this level is the body of a function,
+   so create a block as if KEEP were set and also clear out all
+   label names.
+
+   If REVERSE is nonzero, reverse the order of decls before putting
+   them into the BLOCK.  */
+
+tree
+poplevel (keep, reverse, functionbody)
+     int keep;
+     int reverse;
+     int functionbody;
+{
+  register tree link;
+  /* The chain of decls was accumulated in reverse order.
+     Put it into forward order, just for cleanliness.  */
+  tree decls;
+  tree tags = current_binding_level->tags;
+  tree subblocks = current_binding_level->blocks;
+  tree block = 0;
+  tree decl;
+  int block_previously_created;
+
+  keep |= current_binding_level->keep;
+
+  /* This warning is turned off because it causes warnings for
+     declarations like `extern struct foo *x'.  */
+#if 0
+  /* Warn about incomplete structure types in this level.  */
+  for (link = tags; link; link = TREE_CHAIN (link))
+    if (TYPE_SIZE (TREE_VALUE (link)) == 0)
+      {
+	tree type = TREE_VALUE (link);
+	char *errmsg;
+	switch (TREE_CODE (type))
+	  {
+	  case RECORD_TYPE:
+	    errmsg = "`struct %s' incomplete in scope ending here";
+	    break;
+	  case UNION_TYPE:
+	    errmsg = "`union %s' incomplete in scope ending here";
+	    break;
+	  case ENUMERAL_TYPE:
+	    errmsg = "`enum %s' incomplete in scope ending here";
+	    break;
+	  }
+	if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
+	  error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
+	else
+	  /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
+	  error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+      }
+#endif /* 0 */
+
+  /* Get the decls in the order they were written.
+     Usually current_binding_level->names is in reverse order.
+     But parameter decls were previously put in forward order.  */
+
+  if (reverse)
+    current_binding_level->names
+      = decls = nreverse (current_binding_level->names);
+  else
+    decls = current_binding_level->names;
+
+  /* Output any nested inline functions within this block
+     if they weren't already output.  */
+
+  for (decl = decls; decl; decl = TREE_CHAIN (decl))
+    if (TREE_CODE (decl) == FUNCTION_DECL
+	&& ! TREE_ASM_WRITTEN (decl)
+	&& DECL_INITIAL (decl) != 0
+	&& TREE_ADDRESSABLE (decl))
+      {
+	/* If this decl was copied from a file-scope decl
+	   on account of a block-scope extern decl,
+	   propagate TREE_ADDRESSABLE to the file-scope decl.  */
+	if (DECL_ABSTRACT_ORIGIN (decl) != 0)
+	  TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
+	else
+	  output_inline_function (decl);
+      }
+
+  /* If there were any declarations or structure tags in that level,
+     or if this level is a function body,
+     create a BLOCK to record them for the life of this function.  */
+
+  block = 0;
+  block_previously_created = (current_binding_level->this_block != 0);
+  if (block_previously_created)
+    block = current_binding_level->this_block;
+  else if (keep || functionbody
+	   || (current_binding_level->keep_if_subblocks && subblocks != 0))
+    block = make_node (BLOCK);
+  if (block != 0)
+    {
+      BLOCK_VARS (block) = decls;
+      BLOCK_TYPE_TAGS (block) = tags;
+      BLOCK_SUBBLOCKS (block) = subblocks;
+      remember_end_note (block);
+    }
+
+  /* In each subblock, record that this is its superior.  */
+
+  for (link = subblocks; link; link = TREE_CHAIN (link))
+    BLOCK_SUPERCONTEXT (link) = block;
+
+  /* Clear out the meanings of the local variables of this level.  */
+
+  for (link = decls; link; link = TREE_CHAIN (link))
+    {
+      if (DECL_NAME (link) != 0)
+	{
+	  /* If the ident. was used or addressed via a local extern decl,
+	     don't forget that fact.  */
+	  if (DECL_EXTERNAL (link))
+	    {
+	      if (TREE_USED (link))
+		TREE_USED (DECL_NAME (link)) = 1;
+	      if (TREE_ADDRESSABLE (link))
+		TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
+	    }
+	  IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
+	}
+    }
+
+  /* Restore all name-meanings of the outer levels
+     that were shadowed by this level.  */
+
+  for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
+    IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
+
+  /* If the level being exited is the top level of a function,
+     check over all the labels, and clear out the current
+     (function local) meanings of their names.  */
+
+  if (functionbody)
+    {
+      /* If this is the top level block of a function,
+	 the vars are the function's parameters.
+	 Don't leave them in the BLOCK because they are
+	 found in the FUNCTION_DECL instead.  */
+
+      BLOCK_VARS (block) = 0;
+
+      /* Clear out the definitions of all label names,
+	 since their scopes end here,
+	 and add them to BLOCK_VARS.  */
+
+      for (link = named_labels; link; link = TREE_CHAIN (link))
+	{
+	  register tree label = TREE_VALUE (link);
+
+	  if (DECL_INITIAL (label) == 0)
+	    {
+	      error_with_decl (label, "label `%s' used but not defined");
+	      /* Avoid crashing later.  */
+	      define_label (input_filename, lineno,
+			    DECL_NAME (label));
+	    }
+	  else if (warn_unused && !TREE_USED (label))
+	    warning_with_decl (label, "label `%s' defined but not used");
+	  IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
+
+	  /* Put the labels into the "variables" of the
+	     top-level block, so debugger can see them.  */
+	  TREE_CHAIN (label) = BLOCK_VARS (block);
+	  BLOCK_VARS (block) = label;
+	}
+    }
+
+  /* Pop the current level, and free the structure for reuse.  */
+
+  {
+    register struct binding_level *level = current_binding_level;
+    current_binding_level = current_binding_level->level_chain;
+
+    level->level_chain = free_binding_level;
+    free_binding_level = level;
+  }
+
+  /* Dispose of the block that we just made inside some higher level.  */
+  if (functionbody)
+    DECL_INITIAL (current_function_decl) = block;
+  else if (block)
+    {
+      if (!block_previously_created)
+        current_binding_level->blocks
+          = chainon (current_binding_level->blocks, block);
+    }
+  /* If we did not make a block for the level just exited,
+     any blocks made for inner levels
+     (since they cannot be recorded as subblocks in that level)
+     must be carried forward so they will later become subblocks
+     of something else.  */
+  else if (subblocks)
+    current_binding_level->blocks
+      = chainon (current_binding_level->blocks, subblocks);
+
+  /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
+     binding contour so that they point to the appropriate construct, i.e.
+     either to the current FUNCTION_DECL node, or else to the BLOCK node
+     we just constructed.
+
+     Note that for tagged types whose scope is just the formal parameter
+     list for some function type specification, we can't properly set
+     their TYPE_CONTEXTs here, because we don't have a pointer to the
+     appropriate FUNCTION_TYPE node readily available to us.  For those
+     cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
+     in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
+     node which will represent the "scope" for these "parameter list local"
+     tagged types.
+  */
+
+  if (functionbody)
+    for (link = tags; link; link = TREE_CHAIN (link))
+      TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
+  else if (block)
+    for (link = tags; link; link = TREE_CHAIN (link))
+      TYPE_CONTEXT (TREE_VALUE (link)) = block;
+
+  if (block)
+    TREE_USED (block) = 1;
+  return block;
+}
+
+/* Delete the node BLOCK from the current binding level.
+   This is used for the block inside a stmt expr ({...})
+   so that the block can be reinserted where appropriate.  */
+
+void
+delete_block (block)
+     tree block;
+{
+  tree t;
+  if (current_binding_level->blocks == block)
+    current_binding_level->blocks = TREE_CHAIN (block);
+  for (t = current_binding_level->blocks; t;)
+    {
+      if (TREE_CHAIN (t) == block)
+	TREE_CHAIN (t) = TREE_CHAIN (block);
+      else
+	t = TREE_CHAIN (t);
+    }
+  TREE_CHAIN (block) = NULL;
+  /* Clear TREE_USED which is always set by poplevel.
+     The flag is set again if insert_block is called.  */
+  TREE_USED (block) = 0;
+}
+
+/* Insert BLOCK at the end of the list of subblocks of the
+   current binding level.  This is used when a BIND_EXPR is expanded,
+   to handle the BLOCK node inside teh BIND_EXPR.  */
+
+void
+insert_block (block)
+     tree block;
+{
+  TREE_USED (block) = 1;
+  current_binding_level->blocks
+    = chainon (current_binding_level->blocks, block);
+}
+
+/* Set the BLOCK node for the innermost scope
+   (the one we are currently in).  */
+
+void
+set_block (block)
+     register tree block;
+{
+  current_binding_level->this_block = block;
+}
+
+void
+push_label_level ()
+{
+  register struct binding_level *newlevel;
+
+  /* Reuse or create a struct for this binding level.  */
+
+  if (free_binding_level)
+    {
+      newlevel = free_binding_level;
+      free_binding_level = free_binding_level->level_chain;
+    }
+  else
+    {
+      newlevel = make_binding_level ();
+    }
+
+  /* Add this level to the front of the chain (stack) of label levels.  */
+
+  newlevel->level_chain = label_level_chain;
+  label_level_chain = newlevel;
+
+  newlevel->names = named_labels;
+  newlevel->shadowed = shadowed_labels;
+  named_labels = 0;
+  shadowed_labels = 0;
+}
+
+void
+pop_label_level ()
+{
+  register struct binding_level *level = label_level_chain;
+  tree link, prev;
+
+  /* Clear out the definitions of the declared labels in this level.
+     Leave in the list any ordinary, non-declared labels.  */
+  for (link = named_labels, prev = 0; link;)
+    {
+      if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
+	{
+	  if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
+	    {
+	      error_with_decl (TREE_VALUE (link),
+			       "label `%s' used but not defined");
+	      /* Avoid crashing later.  */
+	      define_label (input_filename, lineno,
+			    DECL_NAME (TREE_VALUE (link)));
+	    }
+	  else if (warn_unused && !TREE_USED (TREE_VALUE (link)))
+	    warning_with_decl (TREE_VALUE (link), 
+			       "label `%s' defined but not used");
+	  IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
+
+	  /* Delete this element from the list.  */
+	  link = TREE_CHAIN (link);
+	  if (prev)
+	    TREE_CHAIN (prev) = link;
+	  else
+	    named_labels = link;
+	}
+      else
+	{
+	  prev = link;
+	  link = TREE_CHAIN (link);
+	}
+    }
+
+  /* Bring back all the labels that were shadowed.  */
+  for (link = shadowed_labels; link; link = TREE_CHAIN (link))
+    if (DECL_NAME (TREE_VALUE (link)) != 0)
+      IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
+	= TREE_VALUE (link);
+
+  named_labels = chainon (named_labels, level->names);
+  shadowed_labels = level->shadowed;
+
+  /* Pop the current level, and free the structure for reuse.  */
+  label_level_chain = label_level_chain->level_chain;
+  level->level_chain = free_binding_level;
+  free_binding_level = level;
+}
+
+/* Push a definition or a declaration of struct, union or enum tag "name".
+   "type" should be the type node.
+   We assume that the tag "name" is not already defined.
+
+   Note that the definition may really be just a forward reference.
+   In that case, the TYPE_SIZE will be zero.  */
+
+void
+pushtag (name, type)
+     tree name, type;
+{
+  register struct binding_level *b;
+
+  /* Find the proper binding level for this type tag.  */
+
+  for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
+    continue;
+
+  if (name)
+    {
+      /* Record the identifier as the type's name if it has none.  */
+
+      if (TYPE_NAME (type) == 0)
+	TYPE_NAME (type) = name;
+    }
+
+  if (b == global_binding_level)
+    b->tags = perm_tree_cons (name, type, b->tags);
+  else
+    b->tags = saveable_tree_cons (name, type, b->tags);
+
+  /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
+     tagged type we just added to the current binding level.  This fake
+     NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
+     to output a representation of a tagged type, and it also gives
+     us a convenient place to record the "scope start" address for the
+     tagged type.  */
+
+  TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
+}
+
+/* Handle when a new declaration NEWDECL
+   has the same name as an old one OLDDECL
+   in the same binding contour.
+   Prints an error message if appropriate.
+
+   If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
+   Otherwise, return 0.  */
+
+static int
+duplicate_decls (newdecl, olddecl)
+     register tree newdecl, olddecl;
+{
+  int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
+  int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
+			   && DECL_INITIAL (newdecl) != 0);
+  tree oldtype = TREE_TYPE (olddecl);
+  tree newtype = TREE_TYPE (newdecl);
+
+  if (TREE_CODE (newtype) == ERROR_MARK
+      || TREE_CODE (oldtype) == ERROR_MARK)
+    types_match = 0;
+
+  /* New decl is completely inconsistent with the old one =>
+     tell caller to replace the old one.
+     This is always an error except in the case of shadowing a builtin.  */
+  if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
+    {
+      if (TREE_CODE (olddecl) == FUNCTION_DECL
+	  && DECL_BUILT_IN (olddecl))
+	{
+	  /* If you declare a built-in function name as static, the
+	     built-in definition is overridden,
+	     but optionally warn this was a bad choice of name.  */
+	  if (!TREE_PUBLIC (newdecl))
+	    {
+	      if (warn_shadow)
+		warning_with_decl (newdecl, "shadowing built-in function `%s'");
+	    }
+	  /* Likewise, if the built-in is not ansi, then programs can
+	     override it even globally without an error.  */
+	  else if (DECL_BUILT_IN_NONANSI (olddecl))
+	    warning_with_decl (newdecl,
+			       "built-in function `%s' declared as non-function");
+	  else
+	    error_with_decl (newdecl,
+			     "built-in function `%s' declared as non-function");
+	}
+      else if (TREE_CODE (olddecl) == FUNCTION_DECL
+	       && DECL_BUILT_IN_NONANSI (olddecl))
+	{
+	  /* If overriding decl is static,
+	     optionally warn this was a bad choice of name.  */
+	  if (!TREE_PUBLIC (newdecl))
+	    {
+	      if (warn_shadow)
+		warning_with_decl (newdecl, "shadowing library function `%s'");
+	    }
+	  /* Otherwise, always warn.  */
+	  else
+	    warning_with_decl (newdecl,
+			       "library function `%s' declared as non-function");
+	}
+      else
+	{
+	  error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
+	  error_with_decl (olddecl, "previous declaration of `%s'");
+	}
+
+      return 0;
+    }
+
+  /* For real parm decl following a forward decl,
+     return 1 so old decl will be reused.  */
+  if (types_match && TREE_CODE (newdecl) == PARM_DECL
+      && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
+    return 1;
+
+  /* The new declaration is the same kind of object as the old one.
+     The declarations may partially match.  Print warnings if they don't
+     match enough.  Ultimately, copy most of the information from the new
+     decl to the old one, and keep using the old one.  */
+
+  if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
+      && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
+      && DECL_INITIAL (olddecl) == 0)
+    /* If -traditional, avoid error for redeclaring fcn
+       after implicit decl.  */
+    ;
+  else if (TREE_CODE (olddecl) == FUNCTION_DECL
+	   && DECL_BUILT_IN (olddecl))
+    {
+      /* A function declaration for a built-in function.  */
+      if (!TREE_PUBLIC (newdecl))
+	{
+	  /* If you declare a built-in function name as static, the
+	     built-in definition is overridden,
+	     but optionally warn this was a bad choice of name.  */
+	  if (warn_shadow)
+	    warning_with_decl (newdecl, "shadowing built-in function `%s'");
+	  /* Discard the old built-in function.  */
+	  return 0;
+	}
+      else if (!types_match)
+	{
+          /* Accept the return type of the new declaration if same modes.  */
+	  tree oldreturntype = TREE_TYPE (TREE_TYPE (olddecl));
+	  tree newreturntype = TREE_TYPE (TREE_TYPE (newdecl));
+          if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
+            {
+	      /* Function types may be shared, so we can't just modify
+		 the return type of olddecl's function type.  */
+	      tree newtype
+		= build_function_type (newreturntype,
+				       TYPE_ARG_TYPES (TREE_TYPE (olddecl)));
+	      
+              types_match = comptypes (TREE_TYPE (newdecl), newtype);
+	      if (types_match)
+		TREE_TYPE (olddecl) = newtype;
+	    }
+	  /* Accept harmless mismatch in first argument type also.
+	     This is for ffs.  */
+	  if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
+	      && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0
+	      && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))) != 0
+	      && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl))) != 0
+	      && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))))
+		  ==
+		  TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl))))))
+	    {
+	      /* Function types may be shared, so we can't just modify
+		 the return type of olddecl's function type.  */
+	      tree newtype
+		= build_function_type (TREE_TYPE (TREE_TYPE (olddecl)),
+				       tree_cons (NULL_TREE, 
+						  TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))),
+						  TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (olddecl)))));
+	      
+              types_match = comptypes (TREE_TYPE (newdecl), newtype);
+	      if (types_match)
+		TREE_TYPE (olddecl) = newtype;
+	    }
+	}
+      if (!types_match)
+	{
+	  /* If types don't match for a built-in, throw away the built-in.  */
+	  warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
+	  return 0;
+	}
+    }
+  else if (TREE_CODE (olddecl) == FUNCTION_DECL
+	   && DECL_SOURCE_LINE (olddecl) == 0)
+    {
+      /* A function declaration for a predeclared function
+	 that isn't actually built in.  */
+      if (!TREE_PUBLIC (newdecl))
+	{
+	  /* If you declare it as static, the
+	     default definition is overridden.  */
+	  return 0;
+	}
+      else if (!types_match)
+	{
+	  /* If the types don't match, preserve volatility indication.
+	     Later on, we will discard everything else about the
+	     default declaration.  */
+	  TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
+	}
+    }
+  /* Permit char *foo () to match void *foo (...) if not pedantic,
+     if one of them came from a system header file.  */
+  else if (!types_match
+	   && TREE_CODE (olddecl) == FUNCTION_DECL
+	   && TREE_CODE (newdecl) == FUNCTION_DECL
+	   && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
+	   && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
+	   && (DECL_IN_SYSTEM_HEADER (olddecl)
+	       || DECL_IN_SYSTEM_HEADER (newdecl))
+	   && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
+		&& TYPE_ARG_TYPES (oldtype) == 0
+		&& self_promoting_args_p (TYPE_ARG_TYPES (newtype))
+		&& TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
+	       ||
+	       (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
+		&& TYPE_ARG_TYPES (newtype) == 0
+		&& self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
+		&& TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
+    {
+      if (pedantic)
+	pedwarn_with_decl (newdecl, "conflicting types for `%s'");
+      /* Make sure we keep void * as ret type, not char *.  */
+      if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
+	TREE_TYPE (newdecl) = newtype = oldtype;
+    }
+  else if (!types_match
+	   /* Permit char *foo (int, ...); followed by char *foo ();
+	      if not pedantic.  */
+	   && ! (TREE_CODE (olddecl) == FUNCTION_DECL
+		 && ! pedantic
+		 /* Return types must still match.  */
+		 && comptypes (TREE_TYPE (oldtype),
+			       TREE_TYPE (newtype))
+		 && TYPE_ARG_TYPES (newtype) == 0))
+    {
+      error_with_decl (newdecl, "conflicting types for `%s'");
+      /* Check for function type mismatch
+	 involving an empty arglist vs a nonempty one.  */
+      if (TREE_CODE (olddecl) == FUNCTION_DECL
+	  && comptypes (TREE_TYPE (oldtype),
+			TREE_TYPE (newtype))
+	  && ((TYPE_ARG_TYPES (oldtype) == 0
+	       && DECL_INITIAL (olddecl) == 0)
+	      ||
+	      (TYPE_ARG_TYPES (newtype) == 0
+	       && DECL_INITIAL (newdecl) == 0)))
+	{
+	  /* Classify the problem further.  */
+	  register tree t = TYPE_ARG_TYPES (oldtype);
+	  if (t == 0)
+	    t = TYPE_ARG_TYPES (newtype);
+	  for (; t; t = TREE_CHAIN (t))
+	    {
+	      register tree type = TREE_VALUE (t);
+
+	      if (TREE_CHAIN (t) == 0
+		  && TYPE_MAIN_VARIANT (type) != void_type_node)
+		{
+		  error ("A parameter list with an ellipsis can't match");
+		  error ("an empty parameter name list declaration.");
+		  break;
+		}
+
+	      if (TYPE_MAIN_VARIANT (type) == float_type_node
+		  || C_PROMOTING_INTEGER_TYPE_P (type))
+		{
+		  error ("An argument type that has a default promotion");
+		  error ("can't match an empty parameter name list declaration.");
+		  break;
+		}
+	    }
+	}
+      error_with_decl (olddecl, "previous declaration of `%s'");
+    }
+  else
+    {
+      char *errmsg = redeclaration_error_message (newdecl, olddecl);
+      if (errmsg)
+	{
+	  error_with_decl (newdecl, errmsg);
+	  error_with_decl (olddecl,
+			   ((DECL_INITIAL (olddecl)
+			     && current_binding_level == global_binding_level)
+			    ? "`%s' previously defined here"
+			    : "`%s' previously declared here"));
+	}
+      else if (TREE_CODE (olddecl) == FUNCTION_DECL
+	       && DECL_INITIAL (olddecl) != 0
+	       && TYPE_ARG_TYPES (oldtype) == 0
+	       && TYPE_ARG_TYPES (newtype) != 0)
+	{
+	  register tree type, parm;
+	  register int nargs;
+	  /* Prototype decl follows defn w/o prototype.  */
+
+	  for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
+	       type = TYPE_ARG_TYPES (newtype),
+	       nargs = 1;
+	       (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) != void_type_node
+		|| TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node);
+	       parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
+	    {
+	      if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
+		  || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
+		{
+		  errmsg = "prototype for `%s' follows and number of arguments";
+		  break;
+		}
+	      /* Type for passing arg must be consistent
+		 with that declared for the arg.  */
+	      if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
+		  /* If -traditional, allow `unsigned int' instead of `int'
+		     in the prototype.  */
+		  && (! (flag_traditional
+			 && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node
+			 && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)))
+		{
+		  errmsg = "prototype for `%s' follows and argument %d";
+		  break;
+		}
+	    }
+	  if (errmsg)
+	    {
+	      error_with_decl (newdecl, errmsg, nargs);
+	      error_with_decl (olddecl,
+			       "doesn't match non-prototype definition here");
+	    }
+	  else
+	    {
+	      warning_with_decl (newdecl, "prototype for `%s' follows");
+	      warning_with_decl (olddecl, "non-prototype definition here");
+	    }
+	}
+      /* Warn about mismatches in various flags.  */
+      else
+	{
+	  /* Warn if function is now inline
+	     but was previously declared not inline and has been called.  */
+	  if (TREE_CODE (olddecl) == FUNCTION_DECL
+	      && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
+	      && TREE_USED (olddecl))
+	    warning_with_decl (newdecl,
+			       "`%s' declared inline after being called");
+	  if (TREE_CODE (olddecl) == FUNCTION_DECL
+	      && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
+	      && DECL_INITIAL (olddecl) != 0)
+	    warning_with_decl (newdecl,
+			       "`%s' declared inline after its definition");
+	  /* It is nice to warn when a function is declared
+	     global first and then static.  */
+	  if (TREE_CODE (olddecl) == FUNCTION_DECL
+	      && TREE_PUBLIC (olddecl)
+	      && !TREE_PUBLIC (newdecl))
+	    warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
+
+	  /* These bits are logically part of the type, for variables.
+	     But not for functions
+	     (where qualifiers are not valid ANSI anyway).  */
+	  if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
+	      && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
+		  || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
+	    pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
+	}
+    }
+
+  /* Optionally warn about more than one declaration for the same name.  */
+  if (warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
+      /* Dont warn about a function declaration
+	 followed by a definition.  */
+      && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
+	   && DECL_INITIAL (olddecl) == 0))
+    {
+      warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
+      warning_with_decl (olddecl, "previous declaration of `%s'");
+    }
+
+  /* Copy all the DECL_... slots specified in the new decl
+     except for any that we copy here from the old type.
+
+     Past this point, we don't change OLDTYPE and NEWTYPE
+     even if we change the types of NEWDECL and OLDDECL.  */
+
+  if (types_match)
+    {
+      /* Merge the data types specified in the two decls.  */
+      if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
+	TREE_TYPE (newdecl)
+	  = TREE_TYPE (olddecl)
+	    = common_type (newtype, oldtype);
+
+      /* Lay the type out, unless already done.  */
+      if (oldtype != TREE_TYPE (newdecl))
+	{
+	  if (TREE_TYPE (newdecl) != error_mark_node)
+	    layout_type (TREE_TYPE (newdecl));
+	  if (TREE_CODE (newdecl) != FUNCTION_DECL
+	      && TREE_CODE (newdecl) != TYPE_DECL
+	      && TREE_CODE (newdecl) != CONST_DECL)
+	    layout_decl (newdecl, 0);
+	}
+      else
+	{
+	  /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
+	  DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
+	  if (TREE_CODE (olddecl) != FUNCTION_DECL)
+	    if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
+	      DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
+	}
+
+      /* Keep the old rtl since we can safely use it.  */
+      DECL_RTL (newdecl) = DECL_RTL (olddecl);
+
+      /* Merge the type qualifiers.  */
+      if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
+	  && !TREE_THIS_VOLATILE (newdecl))
+	TREE_THIS_VOLATILE (olddecl) = 0;
+      if (TREE_READONLY (newdecl))
+	TREE_READONLY (olddecl) = 1;
+      if (TREE_THIS_VOLATILE (newdecl))
+	{
+	  TREE_THIS_VOLATILE (olddecl) = 1;
+	  if (TREE_CODE (newdecl) == VAR_DECL)
+	    make_var_volatile (newdecl);
+	}
+
+      /* Keep source location of definition rather than declaration.  */
+      if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
+	{
+	  DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
+	  DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
+	}
+
+      /* Merge the unused-warning information.  */
+      if (DECL_IN_SYSTEM_HEADER (olddecl))
+	DECL_IN_SYSTEM_HEADER (newdecl) = 1;
+      else if (DECL_IN_SYSTEM_HEADER (newdecl))
+	DECL_IN_SYSTEM_HEADER (olddecl) = 1;
+
+      /* Merge the initialization information.  */
+      if (DECL_INITIAL (newdecl) == 0)
+	DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
+    }
+  /* If cannot merge, then use the new type and qualifiers,
+     and don't preserve the old rtl.  */
+  else
+    {
+      TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
+      TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
+      TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
+      TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
+    }
+
+  /* Merge the storage class information.  */
+  /* For functions, static overrides non-static.  */
+  if (TREE_CODE (newdecl) == FUNCTION_DECL)
+    {
+      TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
+      /* This is since we don't automatically
+	 copy the attributes of NEWDECL into OLDDECL.  */
+      TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
+      /* If this clears `static', clear it in the identifier too.  */
+      if (! TREE_PUBLIC (olddecl))
+	TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
+    }
+  if (DECL_EXTERNAL (newdecl))
+    {
+      TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
+      DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
+      /* An extern decl does not override previous storage class.  */
+      TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
+    }
+  else
+    {
+      TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
+      TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
+    }
+
+  /* If either decl says `inline', this fn is inline,
+     unless its definition was passed already.  */
+  if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
+    DECL_INLINE (olddecl) = 1;
+  DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
+
+  /* Get rid of any built-in function if new arg types don't match it
+     or if we have a function definition.  */
+  if (TREE_CODE (newdecl) == FUNCTION_DECL
+      && DECL_BUILT_IN (olddecl)
+      && (!types_match || new_is_definition))
+    {
+      TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
+      DECL_BUILT_IN (olddecl) = 0;
+    }
+
+  /* If redeclaring a builtin function, and not a definition,
+     it stays built in.
+     Also preserve various other info from the definition.  */
+  if (TREE_CODE (newdecl) == FUNCTION_DECL && !new_is_definition)
+    {
+      if (DECL_BUILT_IN (olddecl))
+	{
+	  DECL_BUILT_IN (newdecl) = 1;
+	  DECL_SET_FUNCTION_CODE (newdecl, DECL_FUNCTION_CODE (olddecl));
+	}
+      else
+	DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
+
+      DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
+      DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
+      DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
+      DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
+    }
+
+  /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
+     But preserve OLDdECL's DECL_UID.  */
+  {
+    register unsigned olddecl_uid = DECL_UID (olddecl);
+
+    bcopy ((char *) newdecl + sizeof (struct tree_common),
+	   (char *) olddecl + sizeof (struct tree_common),
+	   sizeof (struct tree_decl) - sizeof (struct tree_common));
+    DECL_UID (olddecl) = olddecl_uid;
+  }
+
+  return 1;
+}
+
+/* Record a decl-node X as belonging to the current lexical scope.
+   Check for errors (such as an incompatible declaration for the same
+   name already seen in the same scope).
+
+   Returns either X or an old decl for the same name.
+   If an old decl is returned, it may have been smashed
+   to agree with what X says.  */
+
+tree
+pushdecl (x)
+     tree x;
+{
+  register tree t;
+  register tree name = DECL_NAME (x);
+  register struct binding_level *b = current_binding_level;
+
+  DECL_CONTEXT (x) = current_function_decl;
+  /* A local extern declaration for a function doesn't constitute nesting.
+     A local auto declaration does, since it's a forward decl
+     for a nested function coming later.  */
+  if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0
+      && DECL_EXTERNAL (x))
+    DECL_CONTEXT (x) = 0;
+
+  if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level
+      && x != IDENTIFIER_IMPLICIT_DECL (name))
+    warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
+
+  if (name)
+    {
+      char *file;
+      int line;
+
+      t = lookup_name_current_level (name);
+      if (t != 0 && t == error_mark_node)
+	/* error_mark_node is 0 for a while during initialization!  */
+	{
+	  t = 0;
+	  error_with_decl (x, "`%s' used prior to declaration");
+	}
+
+      if (t != 0)
+	{
+	  file = DECL_SOURCE_FILE (t);
+	  line = DECL_SOURCE_LINE (t);
+	}
+
+      if (t != 0 && duplicate_decls (x, t))
+	{
+	  if (TREE_CODE (t) == PARM_DECL)
+	    {
+	      /* Don't allow more than one "real" duplicate
+		 of a forward parm decl.  */
+	      TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
+	      return t;
+	    }
+	  /* If this decl is `static' and an implicit decl was seen previously,
+	     warn.  But don't complain if -traditional,
+	     since traditional compilers don't complain.  */
+	  if (!flag_traditional && TREE_PUBLIC (name)
+	      && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x)
+	      /* We used to warn also for explicit extern followed by static,
+		 but sometimes you need to do it that way.  */
+	      && IDENTIFIER_IMPLICIT_DECL (name) != 0)
+	    {
+	      pedwarn ("`%s' was declared implicitly `extern' and later `static'",
+		       IDENTIFIER_POINTER (name));
+	      pedwarn_with_file_and_line (file, line,
+					  "previous declaration of `%s'",
+					  IDENTIFIER_POINTER (name));
+	    }
+
+	  return t;
+	}
+
+      /* If we are processing a typedef statement, generate a whole new
+	 ..._TYPE node (which will be just an variant of the existing
+	 ..._TYPE node with identical properties) and then install the
+	 TYPE_DECL node generated to represent the typedef name as the
+	 TYPE_NAME of this brand new (duplicate) ..._TYPE node.
+
+	 The whole point here is to end up with a situation where each
+	 and every ..._TYPE node the compiler creates will be uniquely
+	 associated with AT MOST one node representing a typedef name.
+	 This way, even though the compiler substitutes corresponding
+	 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
+	 early on, later parts of the compiler can always do the reverse
+	 translation and get back the corresponding typedef name.  For
+	 example, given:
+
+		typedef struct S MY_TYPE;
+		MY_TYPE object;
+
+	 Later parts of the compiler might only know that `object' was of
+	 type `struct S' if if were not for code just below.  With this
+	 code however, later parts of the compiler see something like:
+
+		struct S' == struct S
+		typedef struct S' MY_TYPE;
+		struct S' object;
+
+	 And they can then deduce (from the node for type struct S') that
+	 the original object declaration was:
+
+		MY_TYPE object;
+
+	 Being able to do this is important for proper support of protoize,
+	 and also for generating precise symbolic debugging information
+	 which takes full account of the programmer's (typedef) vocabulary.
+
+         Obviously, we don't want to generate a duplicate ..._TYPE node if
+	 the TYPE_DECL node that we are now processing really represents a
+	 standard built-in type.
+
+         Since all standard types are effectively declared at line zero
+         in the source file, we can easily check to see if we are working
+         on a standard type by checking the current value of lineno.  */
+
+      if (TREE_CODE (x) == TYPE_DECL)
+        {
+          if (DECL_SOURCE_LINE (x) == 0)
+            {
+	      if (TYPE_NAME (TREE_TYPE (x)) == 0)
+	        TYPE_NAME (TREE_TYPE (x)) = x;
+            }
+          else if (TREE_TYPE (x) != error_mark_node)
+            {
+              tree tt = TREE_TYPE (x);
+
+              tt = build_type_copy (tt);
+              TYPE_NAME (tt) = x;
+              TREE_TYPE (x) = tt;
+            }
+        }
+
+      /* Multiple external decls of the same identifier ought to match.
+	 Check against both global declarations and out of scope (limbo) block
+	 level declarations.
+
+	 We get warnings about inline functions where they are defined.
+	 Avoid duplicate warnings where they are used.  */
+      if (TREE_PUBLIC (x) && ! DECL_INLINE (x))
+	{
+	  tree decl;
+
+	  if (IDENTIFIER_GLOBAL_VALUE (name) != 0
+	      && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
+		  || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
+	    decl = IDENTIFIER_GLOBAL_VALUE (name);
+	  else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
+	    /* Decls in limbo are always extern, so no need to check that.  */
+	    decl = IDENTIFIER_LIMBO_VALUE (name);
+	  else
+	    decl = 0;
+
+	  if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
+	      /* If old decl is built-in, we already warned if we should.  */
+	      && !DECL_BUILT_IN (decl))
+	    {
+	      pedwarn_with_decl (x,
+				 "type mismatch with previous external decl");
+	      pedwarn_with_decl (decl, "previous external decl of `%s'");
+	    }
+	}
+
+      /* If a function has had an implicit declaration, and then is defined,
+	 make sure they are compatible.  */
+
+      if (IDENTIFIER_IMPLICIT_DECL (name) != 0
+	  && IDENTIFIER_GLOBAL_VALUE (name) == 0
+	  && TREE_CODE (x) == FUNCTION_DECL
+	  && ! comptypes (TREE_TYPE (x),
+			  TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
+	{
+	  warning_with_decl (x, "type mismatch with previous implicit declaration");
+	  warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
+			     "previous implicit declaration of `%s'");
+	}
+
+      /* In PCC-compatibility mode, extern decls of vars with no current decl
+	 take effect at top level no matter where they are.  */
+      if (flag_traditional && DECL_EXTERNAL (x)
+	  && lookup_name (name) == 0)
+	{
+	  tree type = TREE_TYPE (x);
+
+	  /* But don't do this if the type contains temporary nodes.  */
+	  while (type)
+	    {
+	      if (type == error_mark_node)
+		break;
+	      if (! TREE_PERMANENT (type))
+		{
+		  warning_with_decl (x, "type of external `%s' is not global");
+		  /* By exiting the loop early, we leave TYPE nonzero,
+		     and thus prevent globalization of the decl.  */
+		  break;
+		}
+	      else if (TREE_CODE (type) == FUNCTION_TYPE
+		       && TYPE_ARG_TYPES (type) != 0)
+		/* The types might not be truly local,
+		   but the list of arg types certainly is temporary.
+		   Since prototypes are nontraditional,
+		   ok not to do the traditional thing.  */
+		break;
+	      type = TREE_TYPE (type);
+	    }
+
+	  if (type == 0)
+	    b = global_binding_level;
+	}
+
+      /* This name is new in its binding level.
+	 Install the new declaration and return it.  */
+      if (b == global_binding_level)
+	{
+	  /* Install a global value.  */
+	  
+	  /* If the first global decl has external linkage,
+	     warn if we later see static one.  */
+	  if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
+	    TREE_PUBLIC (name) = 1;
+
+	  IDENTIFIER_GLOBAL_VALUE (name) = x;
+
+	  /* We no longer care about any previous block level declarations.  */
+	  IDENTIFIER_LIMBO_VALUE (name) = 0;
+
+	  /* Don't forget if the function was used via an implicit decl.  */
+	  if (IDENTIFIER_IMPLICIT_DECL (name)
+	      && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
+	    TREE_USED (x) = 1, TREE_USED (name) = 1;
+
+	  /* Don't forget if its address was taken in that way.  */
+	  if (IDENTIFIER_IMPLICIT_DECL (name)
+	      && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
+	    TREE_ADDRESSABLE (x) = 1;
+
+	  /* Warn about mismatches against previous implicit decl.  */
+	  if (IDENTIFIER_IMPLICIT_DECL (name) != 0
+	      /* If this real decl matches the implicit, don't complain.  */
+	      && ! (TREE_CODE (x) == FUNCTION_DECL
+		    && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
+			== integer_type_node)))
+	    pedwarn ("`%s' was previously implicitly declared to return `int'",
+		     IDENTIFIER_POINTER (name));
+
+	  /* If this decl is `static' and an `extern' was seen previously,
+	     that is erroneous.  */
+	  if (TREE_PUBLIC (name)
+	      && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
+	    {
+	      /* Okay to redeclare an ANSI built-in as static.  */
+	      if (t != 0 && DECL_BUILT_IN (t))
+		;
+	      /* Okay to declare a non-ANSI built-in as anything.  */
+	      else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
+		;
+	      else if (IDENTIFIER_IMPLICIT_DECL (name))
+		pedwarn ("`%s' was declared implicitly `extern' and later `static'",
+			 IDENTIFIER_POINTER (name));
+	      else
+		pedwarn ("`%s' was declared `extern' and later `static'",
+			 IDENTIFIER_POINTER (name));
+	    }
+	}
+      else
+	{
+	  /* Here to install a non-global value.  */
+	  tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
+	  tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
+	  IDENTIFIER_LOCAL_VALUE (name) = x;
+
+	  /* If this is an extern function declaration, see if we
+	     have a global definition or declaration for the function.  */
+	  if (oldlocal == 0
+	      && DECL_EXTERNAL (x) && !DECL_INLINE (x)
+	      && oldglobal != 0
+	      && TREE_CODE (x) == FUNCTION_DECL
+	      && TREE_CODE (oldglobal) == FUNCTION_DECL)
+	    {
+	      /* We have one.  Their types must agree.  */
+	      if (! comptypes (TREE_TYPE (x),
+			       TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
+		pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
+	      else
+		{
+		  /* Inner extern decl is inline if global one is.
+		     Copy enough to really inline it.  */
+		  if (DECL_INLINE (oldglobal))
+		    {
+		      DECL_INLINE (x) = DECL_INLINE (oldglobal);
+		      DECL_INITIAL (x) = (current_function_decl == oldglobal
+					  ? 0 : DECL_INITIAL (oldglobal));
+		      DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
+		      DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
+		      DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
+		      DECL_RESULT (x) = DECL_RESULT (oldglobal);
+		      TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
+		      DECL_ABSTRACT_ORIGIN (x) = oldglobal;
+		    }
+		  /* Inner extern decl is built-in if global one is.  */
+		  if (DECL_BUILT_IN (oldglobal))
+		    {
+		      DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal);
+		      DECL_SET_FUNCTION_CODE (x, DECL_FUNCTION_CODE (oldglobal));
+		    }
+		  /* Keep the arg types from a file-scope fcn defn.  */
+		  if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
+		      && DECL_INITIAL (oldglobal)
+		      && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
+		    TREE_TYPE (x) = TREE_TYPE (oldglobal);
+		}
+	    }
+
+#if 0 /* This case is probably sometimes the right thing to do.  */
+	  /* If we have a local external declaration,
+	     then any file-scope declaration should not
+	     have been static.  */
+	  if (oldlocal == 0 && oldglobal != 0
+	      && !TREE_PUBLIC (oldglobal)
+	      && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
+	    warning ("`%s' locally external but globally static",
+		     IDENTIFIER_POINTER (name));
+#endif
+
+	  /* If we have a local external declaration,
+	     and no file-scope declaration has yet been seen,
+	     then if we later have a file-scope decl it must not be static.  */
+	  if (oldlocal == 0
+	      && oldglobal == 0
+	      && DECL_EXTERNAL (x)
+	      && TREE_PUBLIC (x))
+	    {
+	      TREE_PUBLIC (name) = 1;
+
+	      /* Save this decl, so that we can do type checking against
+		 other decls after it falls out of scope.
+
+		 Only save it once.  This prevents temporary decls created in
+		 expand_inline_function from being used here, since this
+		 will have been set when the inline function was parsed.
+		 It also helps give slightly better warnings.  */
+	      if (IDENTIFIER_LIMBO_VALUE (name) == 0)
+		IDENTIFIER_LIMBO_VALUE (name) = x;
+	    }
+
+	  /* Warn if shadowing an argument at the top level of the body.  */
+	  if (oldlocal != 0 && !DECL_EXTERNAL (x)
+	      /* This warning doesn't apply to the parms of a nested fcn.  */
+	      && ! current_binding_level->parm_flag
+	      /* Check that this is one level down from the parms.  */
+	      && current_binding_level->level_chain->parm_flag
+	      /* Check that the decl being shadowed
+		 comes from the parm level, one level up.  */
+	      && chain_member (oldlocal, current_binding_level->level_chain->names))
+	    {
+	      if (TREE_CODE (oldlocal) == PARM_DECL)
+		pedwarn ("declaration of `%s' shadows a parameter",
+			 IDENTIFIER_POINTER (name));
+	      else
+		pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
+			 IDENTIFIER_POINTER (name));
+	    }
+
+	  /* Maybe warn if shadowing something else.  */
+	  else if (warn_shadow && !DECL_EXTERNAL (x)
+		   /* No shadow warnings for internally generated vars.  */
+		   && DECL_SOURCE_LINE (x) != 0
+		   /* No shadow warnings for vars made for inlining.  */
+		   && ! DECL_FROM_INLINE (x))
+	    {
+	      char *warnstring = 0;
+
+	      if (TREE_CODE (x) == PARM_DECL
+		  && current_binding_level->level_chain->parm_flag)
+		/* Don't warn about the parm names in function declarator
+		   within a function declarator.
+		   It would be nice to avoid warning in any function
+		   declarator in a declaration, as opposed to a definition,
+		   but there is no way to tell it's not a definition.  */
+		;
+	      else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
+		warnstring = "declaration of `%s' shadows a parameter";
+	      else if (oldlocal != 0)
+		warnstring = "declaration of `%s' shadows previous local";
+	      else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
+		       && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
+		warnstring = "declaration of `%s' shadows global declaration";
+
+	      if (warnstring)
+		warning (warnstring, IDENTIFIER_POINTER (name));
+	    }
+
+	  /* If storing a local value, there may already be one (inherited).
+	     If so, record it for restoration when this binding level ends.  */
+	  if (oldlocal != 0)
+	    b->shadowed = tree_cons (name, oldlocal, b->shadowed);
+	}
+
+      /* Keep count of variables in this level with incomplete type.  */
+      if (TYPE_SIZE (TREE_TYPE (x)) == 0)
+	++b->n_incomplete;
+    }
+
+  /* Put decls on list in reverse order.
+     We will reverse them later if necessary.  */
+  TREE_CHAIN (x) = b->names;
+  b->names = x;
+
+  return x;
+}
+
+/* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
+
+tree
+pushdecl_top_level (x)
+     tree x;
+{
+  register tree t;
+  register struct binding_level *b = current_binding_level;
+
+  current_binding_level = global_binding_level;
+  t = pushdecl (x);
+  current_binding_level = b;
+  return t;
+}
+
+/* Generate an implicit declaration for identifier FUNCTIONID
+   as a function of type int ().  Print a warning if appropriate.  */
+
+tree
+implicitly_declare (functionid)
+     tree functionid;
+{
+  register tree decl;
+  int traditional_warning = 0;
+  /* Only one "implicit declaration" warning per identifier.  */
+  int implicit_warning;
+
+  /* Save the decl permanently so we can warn if definition follows.  */
+  push_obstacks_nochange ();
+  end_temporary_allocation ();
+
+  /* We used to reuse an old implicit decl here,
+     but this loses with inline functions because it can clobber
+     the saved decl chains.  */
+/*  if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
+    decl = IDENTIFIER_IMPLICIT_DECL (functionid);
+  else  */
+    decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
+
+  /* Warn of implicit decl following explicit local extern decl.
+     This is probably a program designed for traditional C.  */
+  if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
+    traditional_warning = 1;
+
+  /* Warn once of an implicit declaration.  */
+  implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
+
+  DECL_EXTERNAL (decl) = 1;
+  TREE_PUBLIC (decl) = 1;
+
+  /* Record that we have an implicit decl and this is it.  */
+  IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
+
+  /* ANSI standard says implicit declarations are in the innermost block.
+     So we record the decl in the standard fashion.
+     If flag_traditional is set, pushdecl does it top-level.  */
+  pushdecl (decl);
+
+  /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
+  maybe_objc_check_decl (decl);
+
+  rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
+
+  if (warn_implicit && implicit_warning)
+    warning ("implicit declaration of function `%s'",
+	     IDENTIFIER_POINTER (functionid));
+  else if (warn_traditional && traditional_warning)
+    warning ("function `%s' was previously declared within a block",
+	     IDENTIFIER_POINTER (functionid));
+
+  /* Write a record describing this implicit function declaration to the
+     prototypes file (if requested).  */
+
+  gen_aux_info_record (decl, 0, 1, 0);
+
+  pop_obstacks ();
+
+  return decl;
+}
+
+/* Return zero if the declaration NEWDECL is valid
+   when the declaration OLDDECL (assumed to be for the same name)
+   has already been seen.
+   Otherwise return an error message format string with a %s
+   where the identifier should go.  */
+
+static char *
+redeclaration_error_message (newdecl, olddecl)
+     tree newdecl, olddecl;
+{
+  if (TREE_CODE (newdecl) == TYPE_DECL)
+    {
+      if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
+	return 0;
+      return "redefinition of `%s'";
+    }
+  else if (TREE_CODE (newdecl) == FUNCTION_DECL)
+    {
+      /* Declarations of functions can insist on internal linkage
+	 but they can't be inconsistent with internal linkage,
+	 so there can be no error on that account.
+	 However defining the same name twice is no good.  */
+      if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
+	  /* However, defining once as extern inline and a second
+	     time in another way is ok.  */
+	  && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
+	       && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
+	return "redefinition of `%s'";
+      return 0;
+    }
+  else if (current_binding_level == global_binding_level)
+    {
+      /* Objects declared at top level:  */
+      /* If at least one is a reference, it's ok.  */
+      if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
+	return 0;
+      /* Reject two definitions.  */
+      if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
+	return "redefinition of `%s'";
+      /* Now we have two tentative defs, or one tentative and one real def.  */
+      /* Insist that the linkage match.  */
+      if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
+	return "conflicting declarations of `%s'";
+      return 0;
+    }
+  else if (current_binding_level->parm_flag
+	   && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
+    return 0;
+  else
+    {
+      /* Objects declared with block scope:  */
+      /* Reject two definitions, and reject a definition
+	 together with an external reference.  */
+      if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
+	return "redeclaration of `%s'";
+      return 0;
+    }
+}
+
+/* Get the LABEL_DECL corresponding to identifier ID as a label.
+   Create one if none exists so far for the current function.
+   This function is called for both label definitions and label references.  */
+
+tree
+lookup_label (id)
+     tree id;
+{
+  register tree decl = IDENTIFIER_LABEL_VALUE (id);
+
+  if (current_function_decl == 0)
+    {
+      error ("label %s referenced outside of any function",
+	     IDENTIFIER_POINTER (id));
+      return 0;
+    }
+
+  /* Use a label already defined or ref'd with this name.  */
+  if (decl != 0)
+    {
+      /* But not if it is inherited and wasn't declared to be inheritable.  */
+      if (DECL_CONTEXT (decl) != current_function_decl
+	  && ! C_DECLARED_LABEL_FLAG (decl))
+	return shadow_label (id);
+      return decl;
+    }
+
+  decl = build_decl (LABEL_DECL, id, void_type_node);
+
+  /* Make sure every label has an rtx.  */
+  label_rtx (decl);
+
+  /* A label not explicitly declared must be local to where it's ref'd.  */
+  DECL_CONTEXT (decl) = current_function_decl;
+
+  DECL_MODE (decl) = VOIDmode;
+
+  /* Say where one reference is to the label,
+     for the sake of the error if it is not defined.  */
+  DECL_SOURCE_LINE (decl) = lineno;
+  DECL_SOURCE_FILE (decl) = input_filename;
+
+  IDENTIFIER_LABEL_VALUE (id) = decl;
+
+  named_labels = tree_cons (NULL_TREE, decl, named_labels);
+
+  return decl;
+}
+
+/* Make a label named NAME in the current function,
+   shadowing silently any that may be inherited from containing functions
+   or containing scopes.
+
+   Note that valid use, if the label being shadowed
+   comes from another scope in the same function,
+   requires calling declare_nonlocal_label right away.  */
+
+tree
+shadow_label (name)
+     tree name;
+{
+  register tree decl = IDENTIFIER_LABEL_VALUE (name);
+
+  if (decl != 0)
+    {
+      shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
+      IDENTIFIER_LABEL_VALUE (name) = decl = 0;
+    }
+
+  return lookup_label (name);
+}
+
+/* Define a label, specifying the location in the source file.
+   Return the LABEL_DECL node for the label, if the definition is valid.
+   Otherwise return 0.  */
+
+tree
+define_label (filename, line, name)
+     char *filename;
+     int line;
+     tree name;
+{
+  tree decl = lookup_label (name);
+
+  /* If label with this name is known from an outer context, shadow it.  */
+  if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
+    {
+      shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
+      IDENTIFIER_LABEL_VALUE (name) = 0;
+      decl = lookup_label (name);
+    }
+
+  if (DECL_INITIAL (decl) != 0)
+    {
+      error ("duplicate label `%s'", IDENTIFIER_POINTER (name));
+      return 0;
+    }
+  else
+    {
+      /* Mark label as having been defined.  */
+      DECL_INITIAL (decl) = error_mark_node;
+      /* Say where in the source.  */
+      DECL_SOURCE_FILE (decl) = filename;
+      DECL_SOURCE_LINE (decl) = line;
+      return decl;
+    }
+}
+
+/* Return the list of declarations of the current level.
+   Note that this list is in reverse order unless/until
+   you nreverse it; and when you do nreverse it, you must
+   store the result back using `storedecls' or you will lose.  */
+
+tree
+getdecls ()
+{
+  return current_binding_level->names;
+}
+
+/* Return the list of type-tags (for structs, etc) of the current level.  */
+
+tree
+gettags ()
+{
+  return current_binding_level->tags;
+}
+
+/* Store the list of declarations of the current level.
+   This is done for the parameter declarations of a function being defined,
+   after they are modified in the light of any missing parameters.  */
+
+static void
+storedecls (decls)
+     tree decls;
+{
+  current_binding_level->names = decls;
+}
+
+/* Similarly, store the list of tags of the current level.  */
+
+static void
+storetags (tags)
+     tree tags;
+{
+  current_binding_level->tags = tags;
+}
+
+/* Given NAME, an IDENTIFIER_NODE,
+   return the structure (or union or enum) definition for that name.
+   Searches binding levels from BINDING_LEVEL up to the global level.
+   If THISLEVEL_ONLY is nonzero, searches only the specified context
+   (but skips any tag-transparent contexts to find one that is
+   meaningful for tags).
+   CODE says which kind of type the caller wants;
+   it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
+   If the wrong kind of type is found, an error is reported.  */
+
+static tree
+lookup_tag (code, name, binding_level, thislevel_only)
+     enum tree_code code;
+     struct binding_level *binding_level;
+     tree name;
+     int thislevel_only;
+{
+  register struct binding_level *level;
+
+  for (level = binding_level; level; level = level->level_chain)
+    {
+      register tree tail;
+      for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
+	{
+	  if (TREE_PURPOSE (tail) == name)
+	    {
+	      if (TREE_CODE (TREE_VALUE (tail)) != code)
+		{
+		  /* Definition isn't the kind we were looking for.  */
+		  pending_invalid_xref = name;
+		  pending_invalid_xref_file = input_filename;
+		  pending_invalid_xref_line = lineno;
+		}
+	      return TREE_VALUE (tail);
+	    }
+	}
+      if (thislevel_only && ! level->tag_transparent)
+	return NULL_TREE;
+    }
+  return NULL_TREE;
+}
+
+/* Print an error message now
+   for a recent invalid struct, union or enum cross reference.
+   We don't print them immediately because they are not invalid
+   when used in the `struct foo;' construct for shadowing.  */
+
+void
+pending_xref_error ()
+{
+  if (pending_invalid_xref != 0)
+    error_with_file_and_line (pending_invalid_xref_file,
+			      pending_invalid_xref_line,
+			      "`%s' defined as wrong kind of tag",
+			      IDENTIFIER_POINTER (pending_invalid_xref));
+  pending_invalid_xref = 0;
+}
+
+/* Given a type, find the tag that was defined for it and return the tag name.
+   Otherwise return 0.  */
+
+static tree
+lookup_tag_reverse (type)
+     tree type;
+{
+  register struct binding_level *level;
+
+  for (level = current_binding_level; level; level = level->level_chain)
+    {
+      register tree tail;
+      for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
+	{
+	  if (TREE_VALUE (tail) == type)
+	    return TREE_PURPOSE (tail);
+	}
+    }
+  return NULL_TREE;
+}
+
+/* Look up NAME in the current binding level and its superiors
+   in the namespace of variables, functions and typedefs.
+   Return a ..._DECL node of some kind representing its definition,
+   or return 0 if it is undefined.  */
+
+tree
+lookup_name (name)
+     tree name;
+{
+  register tree val;
+  if (current_binding_level != global_binding_level
+      && IDENTIFIER_LOCAL_VALUE (name))
+    val = IDENTIFIER_LOCAL_VALUE (name);
+  else
+    val = IDENTIFIER_GLOBAL_VALUE (name);
+  return val;
+}
+
+/* Similar to `lookup_name' but look only at current binding level.  */
+
+tree
+lookup_name_current_level (name)
+     tree name;
+{
+  register tree t;
+
+  if (current_binding_level == global_binding_level)
+    return IDENTIFIER_GLOBAL_VALUE (name);
+
+  if (IDENTIFIER_LOCAL_VALUE (name) == 0)
+    return 0;
+
+  for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
+    if (DECL_NAME (t) == name)
+      break;
+
+  return t;
+}
+
+/* Create the predefined scalar types of C,
+   and some nodes representing standard constants (0, 1, (void *)0).
+   Initialize the global binding level.
+   Make definitions for built-in primitive functions.  */
+
+void
+init_decl_processing ()
+{
+  register tree endlink;
+  /* Either char* or void*.  */
+  tree traditional_ptr_type_node;
+  /* Data types of memcpy and strlen.  */
+  tree memcpy_ftype, strlen_ftype;
+  tree void_ftype_any;
+  int wchar_type_size;
+  tree temp;
+  tree array_domain_type;
+
+  current_function_decl = NULL;
+  named_labels = NULL;
+  current_binding_level = NULL_BINDING_LEVEL;
+  free_binding_level = NULL_BINDING_LEVEL;
+  pushlevel (0);	/* make the binding_level structure for global names */
+  global_binding_level = current_binding_level;
+
+  /* Define `int' and `char' first so that dbx will output them first.  */
+
+  integer_type_node = make_signed_type (INT_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
+			integer_type_node));
+
+  /* Define `char', which is like either `signed char' or `unsigned char'
+     but not the same as either.  */
+
+  char_type_node
+    = (flag_signed_char
+       ? make_signed_type (CHAR_TYPE_SIZE)
+       : make_unsigned_type (CHAR_TYPE_SIZE));
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
+			char_type_node));
+
+  long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
+			long_integer_type_node));
+
+  unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
+			unsigned_type_node));
+
+  long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
+			long_unsigned_type_node));
+
+  /* `unsigned long' is the standard type for sizeof.
+     Traditionally, use a signed type.
+     Note that stddef.h uses `unsigned long',
+     and this must agree, even of long and int are the same size.  */
+  if (flag_traditional)
+    sizetype = long_integer_type_node;
+  else
+    sizetype
+      = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
+
+  ptrdiff_type_node
+    = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
+
+  TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
+  TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
+  TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
+  TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
+  TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
+
+  error_mark_node = make_node (ERROR_MARK);
+  TREE_TYPE (error_mark_node) = error_mark_node;
+
+  short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
+			short_integer_type_node));
+
+  long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
+			long_long_integer_type_node));
+
+  short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
+			short_unsigned_type_node));
+
+  long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
+			long_long_unsigned_type_node));
+
+  /* Define both `signed char' and `unsigned char'.  */
+  signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
+			signed_char_type_node));
+
+  unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
+			unsigned_char_type_node));
+
+  intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
+
+  intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
+
+  intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
+
+  intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
+
+  unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
+
+  unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
+
+  unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
+
+  unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
+  pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
+
+  float_type_node = make_node (REAL_TYPE);
+  TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
+  pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
+			float_type_node));
+  layout_type (float_type_node);
+
+  double_type_node = make_node (REAL_TYPE);
+  if (flag_short_double)
+    TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
+  else
+    TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
+  pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
+			double_type_node));
+  layout_type (double_type_node);
+
+  long_double_type_node = make_node (REAL_TYPE);
+  TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
+			long_double_type_node));
+  layout_type (long_double_type_node);
+
+  complex_integer_type_node = make_node (COMPLEX_TYPE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
+			complex_integer_type_node));
+  TREE_TYPE (complex_integer_type_node) = integer_type_node;
+  layout_type (complex_integer_type_node);
+
+  complex_float_type_node = make_node (COMPLEX_TYPE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
+			complex_float_type_node));
+  TREE_TYPE (complex_float_type_node) = float_type_node;
+  layout_type (complex_float_type_node);
+
+  complex_double_type_node = make_node (COMPLEX_TYPE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
+			complex_double_type_node));
+  TREE_TYPE (complex_double_type_node) = double_type_node;
+  layout_type (complex_double_type_node);
+
+  complex_long_double_type_node = make_node (COMPLEX_TYPE);
+  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
+			complex_long_double_type_node));
+  TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
+  layout_type (complex_long_double_type_node);
+
+  wchar_type_node
+    = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
+  wchar_type_size = TYPE_PRECISION (wchar_type_node);
+  signed_wchar_type_node = type_for_size (wchar_type_size, 0);
+  unsigned_wchar_type_node = type_for_size (wchar_type_size, 1);
+
+  integer_zero_node = build_int_2 (0, 0);
+  TREE_TYPE (integer_zero_node) = integer_type_node;
+  integer_one_node = build_int_2 (1, 0);
+  TREE_TYPE (integer_one_node) = integer_type_node;
+
+  size_zero_node = build_int_2 (0, 0);
+  TREE_TYPE (size_zero_node) = sizetype;
+  size_one_node = build_int_2 (1, 0);
+  TREE_TYPE (size_one_node) = sizetype;
+
+  void_type_node = make_node (VOID_TYPE);
+  pushdecl (build_decl (TYPE_DECL,
+			ridpointers[(int) RID_VOID], void_type_node));
+  layout_type (void_type_node);	/* Uses integer_zero_node */
+  /* We are not going to have real types in C with less than byte alignment,
+     so we might as well not have any types that claim to have it.  */
+  TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
+
+  null_pointer_node = build_int_2 (0, 0);
+  TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
+  layout_type (TREE_TYPE (null_pointer_node));
+
+  string_type_node = build_pointer_type (char_type_node);
+  const_string_type_node
+    = build_pointer_type (build_type_variant (char_type_node, 1, 0));
+
+  /* Make a type to be the domain of a few array types
+     whose domains don't really matter.
+     200 is small enough that it always fits in size_t
+     and large enough that it can hold most function names for the
+     initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
+  array_domain_type = build_index_type (build_int_2 (200, 0));
+
+  /* make a type for arrays of characters.
+     With luck nothing will ever really depend on the length of this
+     array type.  */
+  char_array_type_node
+    = build_array_type (char_type_node, array_domain_type);
+  /* Likewise for arrays of ints.  */
+  int_array_type_node
+    = build_array_type (integer_type_node, array_domain_type);
+  /* This is for wide string constants.  */
+  wchar_array_type_node
+    = build_array_type (wchar_type_node, array_domain_type);
+
+  default_function_type
+    = build_function_type (integer_type_node, NULL_TREE);
+
+  ptr_type_node = build_pointer_type (void_type_node);
+  const_ptr_type_node
+    = build_pointer_type (build_type_variant (void_type_node, 1, 0));
+
+  endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
+
+  void_ftype_any
+    = build_function_type (void_type_node, NULL_TREE);
+
+  double_ftype_double
+    = build_function_type (double_type_node,
+			   tree_cons (NULL_TREE, double_type_node, endlink));
+
+  double_ftype_double_double
+    = build_function_type (double_type_node,
+			   tree_cons (NULL_TREE, double_type_node,
+				      tree_cons (NULL_TREE,
+						 double_type_node, endlink)));
+
+  int_ftype_int
+    = build_function_type (integer_type_node,
+			   tree_cons (NULL_TREE, integer_type_node, endlink));
+
+  long_ftype_long
+    = build_function_type (long_integer_type_node,
+			   tree_cons (NULL_TREE,
+				      long_integer_type_node, endlink));
+
+  void_ftype_ptr_ptr_int
+    = build_function_type (void_type_node,
+			   tree_cons (NULL_TREE, ptr_type_node,
+				      tree_cons (NULL_TREE, ptr_type_node,
+						 tree_cons (NULL_TREE,
+							    integer_type_node,
+							    endlink))));
+
+  int_ftype_cptr_cptr_sizet
+    = build_function_type (integer_type_node,
+			   tree_cons (NULL_TREE, const_ptr_type_node,
+				      tree_cons (NULL_TREE, const_ptr_type_node,
+						 tree_cons (NULL_TREE,
+							    sizetype,
+							    endlink))));
+
+  void_ftype_ptr_int_int
+    = build_function_type (void_type_node,
+			   tree_cons (NULL_TREE, ptr_type_node,
+				      tree_cons (NULL_TREE, integer_type_node,
+						 tree_cons (NULL_TREE,
+							    integer_type_node,
+							    endlink))));
+
+  string_ftype_ptr_ptr		/* strcpy prototype */
+    = build_function_type (string_type_node,
+			   tree_cons (NULL_TREE, string_type_node,
+				      tree_cons (NULL_TREE,
+						 const_string_type_node,
+						 endlink)));
+
+  int_ftype_string_string	/* strcmp prototype */
+    = build_function_type (integer_type_node,
+			   tree_cons (NULL_TREE, const_string_type_node,
+				      tree_cons (NULL_TREE,
+						 const_string_type_node,
+						 endlink)));
+
+  strlen_ftype		/* strlen prototype */
+    = build_function_type (flag_traditional ? integer_type_node : sizetype,
+			   tree_cons (NULL_TREE, const_string_type_node,
+				      endlink));
+
+  traditional_ptr_type_node
+    = (flag_traditional ? string_type_node : ptr_type_node);
+
+  memcpy_ftype	/* memcpy prototype */
+    = build_function_type (traditional_ptr_type_node,
+			   tree_cons (NULL_TREE, ptr_type_node,
+				      tree_cons (NULL_TREE, const_ptr_type_node,
+						 tree_cons (NULL_TREE,
+							    sizetype,
+							    endlink))));
+
+  builtin_function ("__builtin_constant_p", int_ftype_int,
+		    BUILT_IN_CONSTANT_P, NULL_PTR);
+
+  builtin_function ("__builtin_return_address",
+		    build_function_type (ptr_type_node, 
+					 tree_cons (NULL_TREE,
+						    unsigned_type_node,
+						    endlink)),
+		    BUILT_IN_RETURN_ADDRESS, NULL_PTR);
+
+  builtin_function ("__builtin_frame_address",
+		    build_function_type (ptr_type_node, 
+					 tree_cons (NULL_TREE,
+						    unsigned_type_node,
+						    endlink)),
+		    BUILT_IN_FRAME_ADDRESS, NULL_PTR);
+
+  builtin_function ("__builtin_alloca",
+		    build_function_type (ptr_type_node,
+					 tree_cons (NULL_TREE,
+						    sizetype,
+						    endlink)),
+		    BUILT_IN_ALLOCA, "alloca");
+  builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
+  /* Define alloca, ffs as builtins.
+     Declare _exit just to mark it as volatile.  */
+  if (! flag_no_builtin && !flag_no_nonansi_builtin)
+    {
+      temp = builtin_function ("alloca",
+			       build_function_type (ptr_type_node,
+						    tree_cons (NULL_TREE,
+							       sizetype,
+							       endlink)),
+			       BUILT_IN_ALLOCA, NULL_PTR);
+      /* Suppress error if redefined as a non-function.  */
+      DECL_BUILT_IN_NONANSI (temp) = 1;
+      temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
+      /* Suppress error if redefined as a non-function.  */
+      DECL_BUILT_IN_NONANSI (temp) = 1;
+      temp = builtin_function ("_exit", void_ftype_any, NOT_BUILT_IN,
+			       NULL_PTR);
+      TREE_THIS_VOLATILE (temp) = 1;
+      TREE_SIDE_EFFECTS (temp) = 1;
+      /* Suppress error if redefined as a non-function.  */
+      DECL_BUILT_IN_NONANSI (temp) = 1;
+    }
+
+  builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
+  builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
+		    NULL_PTR);
+  builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
+		    NULL_PTR);
+  builtin_function ("__builtin_saveregs",
+		    build_function_type (ptr_type_node, NULL_TREE),
+		    BUILT_IN_SAVEREGS, NULL_PTR);
+/* EXPAND_BUILTIN_VARARGS is obsolete.  */
+#if 0
+  builtin_function ("__builtin_varargs",
+		    build_function_type (ptr_type_node,
+					 tree_cons (NULL_TREE,
+						    integer_type_node,
+						    endlink)),
+		    BUILT_IN_VARARGS, NULL_PTR);
+#endif
+  builtin_function ("__builtin_classify_type", default_function_type,
+		    BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
+  builtin_function ("__builtin_next_arg",
+		    build_function_type (ptr_type_node, endlink),
+		    BUILT_IN_NEXT_ARG, NULL_PTR);
+  builtin_function ("__builtin_args_info",
+		    build_function_type (integer_type_node,
+					 tree_cons (NULL_TREE,
+						    integer_type_node,
+						    endlink)),
+		    BUILT_IN_ARGS_INFO, NULL_PTR);
+
+  /* Untyped call and return.  */
+  builtin_function ("__builtin_apply_args",
+		    build_function_type (ptr_type_node, NULL_TREE),
+		    BUILT_IN_APPLY_ARGS, NULL_PTR);
+
+  temp = tree_cons (NULL_TREE,
+		    build_pointer_type (build_function_type (void_type_node,
+							     NULL_TREE)),
+		    tree_cons (NULL_TREE,
+			       ptr_type_node,
+			       tree_cons (NULL_TREE,
+					  sizetype,
+					  endlink)));
+  builtin_function ("__builtin_apply",
+		    build_function_type (ptr_type_node, temp),
+		    BUILT_IN_APPLY, NULL_PTR);
+  builtin_function ("__builtin_return",
+		    build_function_type (void_type_node,
+					 tree_cons (NULL_TREE,
+						    ptr_type_node,
+						    endlink)),
+		    BUILT_IN_RETURN, NULL_PTR);
+
+  /* Currently under experimentation.  */
+  builtin_function ("__builtin_memcpy", memcpy_ftype,
+		    BUILT_IN_MEMCPY, "memcpy");
+  builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
+		    BUILT_IN_MEMCMP, "memcmp");
+  builtin_function ("__builtin_strcmp", int_ftype_string_string,
+		    BUILT_IN_STRCMP, "strcmp");
+  builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
+		    BUILT_IN_STRCPY, "strcpy");
+  builtin_function ("__builtin_strlen", strlen_ftype,
+		    BUILT_IN_STRLEN, "strlen");
+  builtin_function ("__builtin_fsqrt", double_ftype_double, 
+		    BUILT_IN_FSQRT, "sqrt");
+  builtin_function ("__builtin_sin", double_ftype_double, 
+		    BUILT_IN_SIN, "sin");
+  builtin_function ("__builtin_cos", double_ftype_double, 
+		    BUILT_IN_COS, "cos");
+
+  /* In an ANSI C program, it is okay to supply built-in meanings
+     for these functions, since applications cannot validly use them
+     with any other meaning.
+     However, honor the -fno-builtin option.  */
+  if (!flag_no_builtin)
+    {
+      builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
+      builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
+      builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
+      builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
+      builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
+			NULL_PTR);
+      builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
+			NULL_PTR);
+      builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
+			NULL_PTR);
+      builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
+      builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
+      builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
+      builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
+
+      /* Declare these functions volatile
+	 to avoid spurious "control drops through" warnings.  */
+      /* Don't specify the argument types, to avoid errors
+	 from certain code which isn't valid in ANSI but which exists.  */
+      temp = builtin_function ("abort", void_ftype_any, NOT_BUILT_IN,
+			       NULL_PTR);
+      TREE_THIS_VOLATILE (temp) = 1;
+      TREE_SIDE_EFFECTS (temp) = 1;
+      temp = builtin_function ("exit", void_ftype_any, NOT_BUILT_IN, NULL_PTR);
+      TREE_THIS_VOLATILE (temp) = 1;
+      TREE_SIDE_EFFECTS (temp) = 1;
+    }
+
+#if 0
+  /* Support for these has not been written in either expand_builtin
+     or build_function_call.  */
+  builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
+  builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
+  builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
+		    NULL_PTR);
+  builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
+		    NULL_PTR);
+  builtin_function ("__builtin_fmod", double_ftype_double_double,
+		    BUILT_IN_FMOD, NULL_PTR);
+  builtin_function ("__builtin_frem", double_ftype_double_double,
+		    BUILT_IN_FREM, NULL_PTR);
+  builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
+		    BUILT_IN_MEMSET, NULL_PTR);
+  builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
+		    NULL_PTR);
+  builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
+		    NULL_PTR);
+#endif
+
+  /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
+  declare_function_name ();
+
+  start_identifier_warnings ();
+
+  init_format_info_table ();
+
+  init_iterators ();
+
+  incomplete_decl_finalize_hook = finish_incomplete_decl;
+}
+
+/* Return a definition for a builtin function named NAME and whose data type
+   is TYPE.  TYPE should be a function type with argument types.
+   FUNCTION_CODE tells later passes how to compile calls to this function.
+   See tree.h for its possible values.
+
+   If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
+   the name to be called if we can't opencode the function.  */
+
+tree
+builtin_function (name, type, function_code, library_name)
+     char *name;
+     tree type;
+     enum built_in_function function_code;
+     char *library_name;
+{
+  tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
+  DECL_EXTERNAL (decl) = 1;
+  TREE_PUBLIC (decl) = 1;
+  /* If -traditional, permit redefining a builtin function any way you like.
+     (Though really, if the program redefines these functions,
+     it probably won't work right unless compiled with -fno-builtin.)  */
+  if (flag_traditional && name[0] != '_')
+    DECL_BUILT_IN_NONANSI (decl) = 1;
+  if (library_name)
+    DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+  make_decl_rtl (decl, NULL_PTR, 1);
+  pushdecl (decl);
+  if (function_code != NOT_BUILT_IN)
+    {
+      DECL_BUILT_IN (decl) = 1;
+      DECL_SET_FUNCTION_CODE (decl, function_code);
+    }
+  /* Warn if a function in the namespace for users
+     is used without an occasion to consider it declared.  */
+  if (name[0] != '_' || name[1] != '_')
+    C_DECL_ANTICIPATED (decl) = 1;
+
+  return decl;
+}
+
+/* Called when a declaration is seen that contains no names to declare.
+   If its type is a reference to a structure, union or enum inherited
+   from a containing scope, shadow that tag name for the current scope
+   with a forward reference.
+   If its type defines a new named structure or union
+   or defines an enum, it is valid but we need not do anything here.
+   Otherwise, it is an error.  */
+
+void
+shadow_tag (declspecs)
+     tree declspecs;
+{
+  shadow_tag_warned (declspecs, 0);
+}
+
+void
+shadow_tag_warned (declspecs, warned)
+     tree declspecs;
+     int warned;
+     /* 1 => we have done a pedwarn.  2 => we have done a warning, but
+	no pedwarn.  */
+{
+  int found_tag = 0;
+  register tree link;
+
+  pending_invalid_xref = 0;
+
+  for (link = declspecs; link; link = TREE_CHAIN (link))
+    {
+      register tree value = TREE_VALUE (link);
+      register enum tree_code code = TREE_CODE (value);
+
+      if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
+	/* Used to test also that TYPE_SIZE (value) != 0.
+	   That caused warning for `struct foo;' at top level in the file.  */
+	{
+	  register tree name = lookup_tag_reverse (value);
+	  register tree t;
+
+	  found_tag++;
+
+	  if (name == 0)
+	    {
+	      if (warned != 1 && code != ENUMERAL_TYPE)
+		/* Empty unnamed enum OK */
+		{
+		  pedwarn ("unnamed struct/union that defines no instances");
+		  warned = 1;
+		}
+	    }
+	  else
+	    {
+	      t = lookup_tag (code, name, current_binding_level, 1);
+
+	      if (t == 0)
+		{
+		  t = make_node (code);
+		  pushtag (name, t);
+		}
+	    }
+	}
+      else
+	{
+	  if (!warned)
+	    {
+	      warning ("useless keyword or type name in empty declaration");
+	      warned = 2;
+	    }
+	}
+    }
+
+  if (found_tag > 1)
+    error ("two types specified in one empty declaration");
+
+  if (warned != 1)
+    {
+      if (found_tag == 0)
+	pedwarn ("empty declaration");
+    }
+}
+
+/* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
+
+tree
+groktypename (typename)
+     tree typename;
+{
+  if (TREE_CODE (typename) != TREE_LIST)
+    return typename;
+  return grokdeclarator (TREE_VALUE (typename),
+			 TREE_PURPOSE (typename),
+			 TYPENAME, 0);
+}
+
+/* Return a PARM_DECL node for a given pair of specs and declarator.  */
+
+tree
+groktypename_in_parm_context (typename)
+     tree typename;
+{
+  if (TREE_CODE (typename) != TREE_LIST)
+    return typename;
+  return grokdeclarator (TREE_VALUE (typename),
+			 TREE_PURPOSE (typename),
+			 PARM, 0);
+}
+
+/* Decode a declarator in an ordinary declaration or data definition.
+   This is called as soon as the type information and variable name
+   have been parsed, before parsing the initializer if any.
+   Here we create the ..._DECL node, fill in its type,
+   and put it on the list of decls for the current context.
+   The ..._DECL node is returned as the value.
+
+   Exception: for arrays where the length is not specified,
+   the type is left null, to be filled in by `finish_decl'.
+
+   Function definitions do not come here; they go to start_function
+   instead.  However, external and forward declarations of functions
+   do go through here.  Structure field declarations are done by
+   grokfield and not through here.  */
+
+/* Set this to zero to debug not using the temporary obstack
+   to parse initializers.  */
+int debug_temp_inits = 1;
+
+tree
+start_decl (declarator, declspecs, initialized)
+     tree declarator, declspecs;
+     int initialized;
+{
+  register tree decl = grokdeclarator (declarator, declspecs,
+				       NORMAL, initialized);
+  register tree tem;
+  int init_written = initialized;
+
+  /* The corresponding pop_obstacks is in finish_decl.  */
+  push_obstacks_nochange ();
+
+  if (initialized)
+    /* Is it valid for this decl to have an initializer at all?
+       If not, set INITIALIZED to zero, which will indirectly
+       tell `finish_decl' to ignore the initializer once it is parsed.  */
+    switch (TREE_CODE (decl))
+      {
+      case TYPE_DECL:
+	/* typedef foo = bar  means give foo the same type as bar.
+	   We haven't parsed bar yet, so `finish_decl' will fix that up.
+	   Any other case of an initialization in a TYPE_DECL is an error.  */
+	if (pedantic || list_length (declspecs) > 1)
+	  {
+	    error ("typedef `%s' is initialized",
+		   IDENTIFIER_POINTER (DECL_NAME (decl)));
+	    initialized = 0;
+	  }
+	break;
+
+      case FUNCTION_DECL:
+	error ("function `%s' is initialized like a variable",
+	       IDENTIFIER_POINTER (DECL_NAME (decl)));
+	initialized = 0;
+	break;
+
+      case PARM_DECL:
+	/* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
+	error ("parameter `%s' is initialized",
+	       IDENTIFIER_POINTER (DECL_NAME (decl)));
+	initialized = 0;
+	break;
+
+      default:
+	/* Don't allow initializations for incomplete types
+	   except for arrays which might be completed by the initialization.  */
+	if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
+	  {
+	    /* A complete type is ok if size is fixed.  */
+
+	    if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
+		|| C_DECL_VARIABLE_SIZE (decl))
+	      {
+		error ("variable-sized object may not be initialized");
+		initialized = 0;
+	      }
+	  }
+	else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
+	  {
+	    error ("variable `%s' has initializer but incomplete type",
+		   IDENTIFIER_POINTER (DECL_NAME (decl)));
+	    initialized = 0;
+	  }
+	else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
+	  {
+	    error ("elements of array `%s' have incomplete type",
+		   IDENTIFIER_POINTER (DECL_NAME (decl)));
+	    initialized = 0;
+	  }
+      }
+
+  if (initialized)
+    {
+#if 0  /* Seems redundant with grokdeclarator.  */
+      if (current_binding_level != global_binding_level
+	  && DECL_EXTERNAL (decl)
+	  && TREE_CODE (decl) != FUNCTION_DECL)
+	warning ("declaration of `%s' has `extern' and is initialized",
+		 IDENTIFIER_POINTER (DECL_NAME (decl)));
+#endif
+      DECL_EXTERNAL (decl) = 0;
+      if (current_binding_level == global_binding_level)
+	TREE_STATIC (decl) = 1;
+
+      /* Tell `pushdecl' this is an initialized decl
+	 even though we don't yet have the initializer expression.
+	 Also tell `finish_decl' it may store the real initializer.  */
+      DECL_INITIAL (decl) = error_mark_node;
+    }
+
+  /* If this is a function declaration, write a record describing it to the
+     prototypes file (if requested).  */
+
+  if (TREE_CODE (decl) == FUNCTION_DECL)
+    gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
+
+  /* Add this decl to the current binding level.
+     TEM may equal DECL or it may be a previous decl of the same name.  */
+  tem = pushdecl (decl);
+
+  /* For a local variable, define the RTL now.  */
+  if (current_binding_level != global_binding_level
+      /* But not if this is a duplicate decl
+	 and we preserved the rtl from the previous one
+	 (which may or may not happen).  */
+      && DECL_RTL (tem) == 0)
+    {
+      if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
+	expand_decl (tem);
+      else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
+	       && DECL_INITIAL (tem) != 0)
+	expand_decl (tem);
+    }
+
+  if (init_written)
+    {
+      /* When parsing and digesting the initializer,
+	 use temporary storage.  Do this even if we will ignore the value.  */
+      if (current_binding_level == global_binding_level && debug_temp_inits)
+	temporary_allocation ();
+    }
+
+  return tem;
+}
+
+/* Finish processing of a declaration;
+   install its initial value.
+   If the length of an array type is not known before,
+   it must be determined now, from the initial value, or it is an error.  */
+
+void
+finish_decl (decl, init, asmspec_tree)
+     tree decl, init;
+     tree asmspec_tree;
+{
+  register tree type = TREE_TYPE (decl);
+  int was_incomplete = (DECL_SIZE (decl) == 0);
+  int temporary = allocation_temporary_p ();
+  char *asmspec = 0;
+
+  if (asmspec_tree)
+    asmspec = TREE_STRING_POINTER (asmspec_tree);
+
+  /* If `start_decl' didn't like having an initialization, ignore it now.  */
+
+  if (init != 0 && DECL_INITIAL (decl) == 0)
+    init = 0;
+  /* Don't crash if parm is initialized.  */
+  if (TREE_CODE (decl) == PARM_DECL)
+    init = 0;
+
+  if (ITERATOR_P (decl))
+    {
+      if (init == 0)
+	error_with_decl (decl, "iterator has no initial value");
+      else
+	init = save_expr (init);
+    }
+
+  if (init)
+    {
+      if (TREE_CODE (decl) != TYPE_DECL)
+	store_init_value (decl, init);
+      else
+	{
+	  /* typedef foo = bar; store the type of bar as the type of foo.  */
+	  TREE_TYPE (decl) = TREE_TYPE (init);
+	  DECL_INITIAL (decl) = init = 0;
+	}
+    }
+
+  /* Pop back to the obstack that is current for this binding level.
+     This is because MAXINDEX, rtl, etc. to be made below
+     must go in the permanent obstack.  But don't discard the
+     temporary data yet.  */
+  pop_obstacks ();
+#if 0 /* pop_obstacks was near the end; this is what was here.  */
+  if (current_binding_level == global_binding_level && temporary)
+    end_temporary_allocation ();
+#endif
+
+  /* Deduce size of array from initialization, if not already known */
+
+  if (TREE_CODE (type) == ARRAY_TYPE
+      && TYPE_DOMAIN (type) == 0
+      && TREE_CODE (decl) != TYPE_DECL)
+    {
+      int do_default
+	= (TREE_STATIC (decl)
+	   /* Even if pedantic, an external linkage array
+	      may have incomplete type at first.  */
+	   ? pedantic && !TREE_PUBLIC (decl)
+	   : !DECL_EXTERNAL (decl));
+      int failure
+	= complete_array_type (type, DECL_INITIAL (decl), do_default);
+
+      /* Get the completed type made by complete_array_type.  */
+      type = TREE_TYPE (decl);
+
+      if (failure == 1)
+	error_with_decl (decl, "initializer fails to determine size of `%s'");
+
+      if (failure == 2)
+	{
+	  if (do_default)
+	    error_with_decl (decl, "array size missing in `%s'");
+	  /* If a `static' var's size isn't known,
+	     make it extern as well as static, so it does not get
+	     allocated.
+	     If it is not `static', then do not mark extern;
+	     finish_incomplete_decl will give it a default size
+	     and it will get allocated.  */
+	  else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
+	    DECL_EXTERNAL (decl) = 1;
+	}
+
+      if (pedantic && TYPE_DOMAIN (type) != 0
+	  && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
+			      integer_zero_node))
+	error_with_decl (decl, "zero-size array `%s'");
+
+      layout_decl (decl, 0);
+    }
+
+  if (TREE_CODE (decl) == VAR_DECL)
+    {
+      if (DECL_SIZE (decl) == 0
+	  && TYPE_SIZE (TREE_TYPE (decl)) != 0)
+	layout_decl (decl, 0);
+
+      if (DECL_SIZE (decl) == 0
+	  && (TREE_STATIC (decl)
+	      ?
+		/* A static variable with an incomplete type
+		   is an error if it is initialized or `static'.
+		   Otherwise, let it through, but if it is not `extern'
+		   then it may cause an error message later.  */
+		!TREE_PUBLIC (decl) || DECL_INITIAL (decl)
+	      :
+		/* An automatic variable with an incomplete type
+		   is an error.  */
+		!DECL_EXTERNAL (decl)))
+	{
+	  error_with_decl (decl, "storage size of `%s' isn't known");
+	  TREE_TYPE (decl) = error_mark_node;
+	}
+
+      if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
+	  && DECL_SIZE (decl) != 0)
+	{
+	  if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
+	    constant_expression_warning (DECL_SIZE (decl));
+	  else
+	    error_with_decl (decl, "storage size of `%s' isn't constant");
+	}
+    }
+
+  /* Output the assembler code and/or RTL code for variables and functions,
+     unless the type is an undefined structure or union.
+     If not, it will get done when the type is completed.  */
+
+  if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
+    {
+      if (flag_traditional && allocation_temporary_p ())
+	{
+	  push_obstacks_nochange ();
+	  end_temporary_allocation ();
+	  /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
+	  maybe_objc_check_decl (decl);
+	  rest_of_decl_compilation (decl, asmspec,
+				    current_binding_level == global_binding_level,
+				    0);
+	  pop_obstacks ();
+	}
+      else
+	{
+	  /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
+	  maybe_objc_check_decl (decl);
+	  rest_of_decl_compilation (decl, asmspec,
+				    current_binding_level == global_binding_level,
+				    0);
+	}
+      if (current_binding_level != global_binding_level)
+	{
+	  /* Recompute the RTL of a local array now
+	     if it used to be an incomplete type.  */
+	  if (was_incomplete
+	      && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
+	    {
+	      /* If we used it already as memory, it must stay in memory.  */
+	      TREE_ADDRESSABLE (decl) = TREE_USED (decl);
+	      /* If it's still incomplete now, no init will save it.  */
+	      if (DECL_SIZE (decl) == 0)
+		DECL_INITIAL (decl) = 0;
+	      expand_decl (decl);
+	    }
+	  /* Compute and store the initial value.  */
+	  if (TREE_CODE (decl) != FUNCTION_DECL)
+	    expand_decl_init (decl);
+	}
+    }
+
+  if (TREE_CODE (decl) == TYPE_DECL)
+    {
+      /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
+      maybe_objc_check_decl (decl);
+      rest_of_decl_compilation (decl, NULL_PTR,
+				current_binding_level == global_binding_level,
+				0);
+    }
+
+  /* ??? After 2.3, test (init != 0) instead of TREE_CODE.  */
+  if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
+      && temporary && TREE_PERMANENT (decl)
+      /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
+	 space with DECL_ARG_TYPE.  */
+      && TREE_CODE (decl) != PARM_DECL)
+    {
+      /* We need to remember that this array HAD an initialization,
+	 but discard the actual temporary nodes,
+	 since we can't have a permanent node keep pointing to them.  */
+      /* We make an exception for inline functions, since it's
+	 normal for a local extern redeclaration of an inline function
+	 to have a copy of the top-level decl's DECL_INLINE.  */
+      if (DECL_INITIAL (decl) != 0)
+	DECL_INITIAL (decl) = error_mark_node;
+    }
+
+#if 0
+  /* Resume permanent allocation, if not within a function.  */
+  /* The corresponding push_obstacks_nochange is in start_decl,
+     and in push_parm_decl and in grokfield.  */
+  pop_obstacks ();
+#endif
+
+  /* If we have gone back from temporary to permanent allocation,
+     actually free the temporary space that we no longer need.  */
+  if (temporary && !allocation_temporary_p ())
+    permanent_allocation ();
+
+  /* At the end of a declaration, throw away any variable type sizes
+     of types defined inside that declaration.  There is no use
+     computing them in the following function definition.  */
+  if (current_binding_level == global_binding_level)
+    get_pending_sizes ();
+}
+
+/* If DECL has a cleanup, build and return that cleanup here.
+   This is a callback called by expand_expr.  */
+
+tree
+maybe_build_cleanup (decl)
+     tree decl;
+{
+  /* There are no cleanups in C.  */
+  return NULL_TREE;
+}
+
+/* Given a parsed parameter declaration,
+   decode it into a PARM_DECL and push that on the current binding level.
+   Also, for the sake of forward parm decls,
+   record the given order of parms in `parm_order'.  */
+
+void
+push_parm_decl (parm)
+     tree parm;
+{
+  tree decl, olddecl;
+  int old_immediate_size_expand = immediate_size_expand;
+  /* Don't try computing parm sizes now -- wait till fn is called.  */
+  immediate_size_expand = 0;
+
+  /* The corresponding pop_obstacks is in finish_decl.  */
+  push_obstacks_nochange ();
+
+  decl = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), PARM, 0);
+
+#if 0
+  if (DECL_NAME (decl))
+    {
+      olddecl = lookup_name (DECL_NAME (decl));
+      if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
+	pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
+    }
+#endif
+
+  decl = pushdecl (decl);
+
+  immediate_size_expand = old_immediate_size_expand;
+
+  current_binding_level->parm_order
+    = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
+
+  /* Add this decl to the current binding level.  */
+  finish_decl (decl, NULL_TREE, NULL_TREE);
+}
+
+/* Clear the given order of parms in `parm_order'.
+   Used at start of parm list,
+   and also at semicolon terminating forward decls.  */
+
+void
+clear_parm_order ()
+{
+  current_binding_level->parm_order = NULL_TREE;
+}
+
+/* Make TYPE a complete type based on INITIAL_VALUE.
+   Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
+   2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
+
+int
+complete_array_type (type, initial_value, do_default)
+     tree type;
+     tree initial_value;
+     int do_default;
+{
+  register tree maxindex = NULL_TREE;
+  int value = 0;
+
+  if (initial_value)
+    {
+      /* Note MAXINDEX  is really the maximum index,
+	 one less than the size.  */
+      if (TREE_CODE (initial_value) == STRING_CST)
+	{
+	  int eltsize
+	    = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
+	  maxindex = build_int_2 (TREE_STRING_LENGTH (initial_value) / eltsize - 1, 0);
+	}
+      else if (TREE_CODE (initial_value) == CONSTRUCTOR)
+	{
+	  register int nelts
+	    = list_length (CONSTRUCTOR_ELTS (initial_value));
+	  maxindex = build_int_2 (nelts - 1, - (nelts == 0));
+	}
+      else
+	{
+	  /* Make an error message unless that happened already.  */
+	  if (initial_value != error_mark_node)
+	    value = 1;
+
+	  /* Prevent further error messages.  */
+	  maxindex = build_int_2 (0, 0);
+	}
+    }
+
+  if (!maxindex)
+    {
+      if (do_default)
+	maxindex = build_int_2 (0, 0);
+      value = 2;
+    }
+
+  if (maxindex)
+    {
+      TYPE_DOMAIN (type) = build_index_type (maxindex);
+      if (!TREE_TYPE (maxindex))
+	TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
+#if 0 /* I took out this change
+	 together with the change in build_array_type. --rms  */
+      change_main_variant (type,
+			   build_array_type (TREE_TYPE (type),
+					     TYPE_DOMAIN (type)));
+#endif
+    }
+
+  /* Lay out the type now that we can get the real answer.  */
+
+  layout_type (type);
+
+  return value;
+}
+
+/* Given declspecs and a declarator,
+   determine the name and type of the object declared
+   and construct a ..._DECL node for it.
+   (In one case we can return a ..._TYPE node instead.
+    For invalid input we sometimes return 0.)
+
+   DECLSPECS is a chain of tree_list nodes whose value fields
+    are the storage classes and type specifiers.
+
+   DECL_CONTEXT says which syntactic context this declaration is in:
+     NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
+     FUNCDEF for a function definition.  Like NORMAL but a few different
+      error messages in each case.  Return value may be zero meaning
+      this definition is too screwy to try to parse.
+     PARM for a parameter declaration (either within a function prototype
+      or before a function body).  Make a PARM_DECL, or return void_type_node.
+     TYPENAME if for a typename (in a cast or sizeof).
+      Don't make a DECL node; just return the ..._TYPE node.
+     FIELD for a struct or union field; make a FIELD_DECL.
+     BITFIELD for a field with specified width.
+   INITIALIZED is 1 if the decl has an initializer.
+
+   In the TYPENAME case, DECLARATOR is really an absolute declarator.
+   It may also be so in the PARM case, for a prototype where the
+   argument type is specified but not the name.
+
+   This function is where the complicated C meanings of `static'
+   and `extern' are interpreted.  */
+
+static tree
+grokdeclarator (declarator, declspecs, decl_context, initialized)
+     tree declspecs;
+     tree declarator;
+     enum decl_context decl_context;
+     int initialized;
+{
+  int specbits = 0;
+  tree spec;
+  tree type = NULL_TREE;
+  int longlong = 0;
+  int constp;
+  int volatilep;
+  int inlinep;
+  int explicit_int = 0;
+  int explicit_char = 0;
+  int defaulted_int = 0;
+  tree typedef_decl = 0;
+  char *name;
+  tree typedef_type = 0;
+  int funcdef_flag = 0;
+  enum tree_code innermost_code = ERROR_MARK;
+  int bitfield = 0;
+  int size_varies = 0;
+
+  if (decl_context == BITFIELD)
+    bitfield = 1, decl_context = FIELD;
+
+  if (decl_context == FUNCDEF)
+    funcdef_flag = 1, decl_context = NORMAL;
+
+  push_obstacks_nochange ();
+
+  if (flag_traditional && allocation_temporary_p ())
+    end_temporary_allocation ();
+
+  /* Look inside a declarator for the name being declared
+     and get it as a string, for an error message.  */
+  {
+    register tree decl = declarator;
+    name = 0;
+
+    while (decl)
+      switch (TREE_CODE (decl))
+	{
+	case ARRAY_REF:
+	case INDIRECT_REF:
+	case CALL_EXPR:
+	  innermost_code = TREE_CODE (decl);
+	  decl = TREE_OPERAND (decl, 0);
+	  break;
+
+	case IDENTIFIER_NODE:
+	  name = IDENTIFIER_POINTER (decl);
+	  decl = 0;
+	  break;
+
+	default:
+	  abort ();
+	}
+    if (name == 0)
+      name = "type name";
+  }
+
+  /* A function definition's declarator must have the form of
+     a function declarator.  */
+
+  if (funcdef_flag && innermost_code != CALL_EXPR)
+    return 0;
+
+  /* Anything declared one level down from the top level
+     must be one of the parameters of a function
+     (because the body is at least two levels down).  */
+
+  /* If this looks like a function definition, make it one,
+     even if it occurs where parms are expected.
+     Then store_parm_decls will reject it and not use it as a parm.  */
+  if (decl_context == NORMAL && !funcdef_flag
+      && current_binding_level->level_chain == global_binding_level)
+    decl_context = PARM;
+
+  /* Look through the decl specs and record which ones appear.
+     Some typespecs are defined as built-in typenames.
+     Others, the ones that are modifiers of other types,
+     are represented by bits in SPECBITS: set the bits for
+     the modifiers that appear.  Storage class keywords are also in SPECBITS.
+
+     If there is a typedef name or a type, store the type in TYPE.
+     This includes builtin typedefs such as `int'.
+
+     Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
+     and did not come from a user typedef.
+
+     Set LONGLONG if `long' is mentioned twice.  */
+
+  for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
+    {
+      register int i;
+      register tree id = TREE_VALUE (spec);
+
+      if (id == ridpointers[(int) RID_INT])
+	explicit_int = 1;
+      if (id == ridpointers[(int) RID_CHAR])
+	explicit_char = 1;
+
+      if (TREE_CODE (id) == IDENTIFIER_NODE)
+	for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
+	  {
+	    if (ridpointers[i] == id)
+	      {
+		if (i == (int) RID_LONG && specbits & (1<<i))
+		  {
+		    if (longlong)
+		      error ("`long long long' is too long for GCC");
+		    else
+		      {
+			if (pedantic)
+			  pedwarn ("ANSI C does not support `long long'");
+			longlong = 1;
+		      }
+		  }
+		else if (specbits & (1 << i))
+		  pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
+		specbits |= 1 << i;
+		goto found;
+	      }
+	  }
+      if (type)
+	error ("two or more data types in declaration of `%s'", name);
+      /* Actual typedefs come to us as TYPE_DECL nodes.  */
+      else if (TREE_CODE (id) == TYPE_DECL)
+	{
+	  type = TREE_TYPE (id);
+	  typedef_decl = id;
+	}
+      /* Built-in types come as identifiers.  */
+      else if (TREE_CODE (id) == IDENTIFIER_NODE)
+	{
+	  register tree t = lookup_name (id);
+	  if (TREE_TYPE (t) == error_mark_node)
+	    ;
+	  else if (!t || TREE_CODE (t) != TYPE_DECL)
+	    error ("`%s' fails to be a typedef or built in type",
+		   IDENTIFIER_POINTER (id));
+	  else
+	    {
+	      type = TREE_TYPE (t);
+	      typedef_decl = t;
+	    }
+	}
+      else if (TREE_CODE (id) != ERROR_MARK)
+	type = id;
+
+    found: {}
+    }
+
+  typedef_type = type;
+  if (type)
+    size_varies = C_TYPE_VARIABLE_SIZE (type);
+
+  /* No type at all: default to `int', and set DEFAULTED_INT
+     because it was not a user-defined typedef.  */
+
+  if (type == 0)
+    {
+      if (funcdef_flag && warn_return_type
+	  && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
+			    | (1 << (int) RID_SIGNED) | (1 << (int) RID_UNSIGNED))))
+	warn_about_return_type = 1;
+      defaulted_int = 1;
+      type = integer_type_node;
+    }
+
+  /* Now process the modifiers that were specified
+     and check for invalid combinations.  */
+
+  /* Long double is a special combination.  */
+
+  if ((specbits & 1 << (int) RID_LONG)
+      && TYPE_MAIN_VARIANT (type) == double_type_node)
+    {
+      specbits &= ~ (1 << (int) RID_LONG);
+      type = long_double_type_node;
+    }
+
+  /* Check all other uses of type modifiers.  */
+
+  if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
+		  | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
+    {
+      int ok = 0;
+
+      if (TREE_CODE (type) != INTEGER_TYPE)
+	error ("long, short, signed or unsigned invalid for `%s'", name);
+      else if ((specbits & 1 << (int) RID_LONG)
+	       && (specbits & 1 << (int) RID_SHORT))
+	error ("long and short specified together for `%s'", name);
+      else if (((specbits & 1 << (int) RID_LONG)
+		|| (specbits & 1 << (int) RID_SHORT))
+	       && explicit_char)
+	error ("long or short specified with char for `%s'", name);
+      else if (((specbits & 1 << (int) RID_LONG)
+		|| (specbits & 1 << (int) RID_SHORT))
+	       && TREE_CODE (type) == REAL_TYPE)
+	error ("long or short specified with floating type for `%s'", name);
+      else if ((specbits & 1 << (int) RID_SIGNED)
+	       && (specbits & 1 << (int) RID_UNSIGNED))
+	error ("signed and unsigned given together for `%s'", name);
+      else
+	{
+	  ok = 1;
+	  if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
+	    {
+	      pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
+		       name);
+	      if (flag_pedantic_errors)
+		ok = 0;
+	    }
+	}
+
+      /* Discard the type modifiers if they are invalid.  */
+      if (! ok)
+	{
+	  specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
+			| (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
+	  longlong = 0;
+	}
+    }
+
+  /* Decide whether an integer type is signed or not.
+     Optionally treat bitfields as signed by default.  */
+  if (specbits & 1 << (int) RID_UNSIGNED
+      /* Traditionally, all bitfields are unsigned.  */
+      || (bitfield && flag_traditional
+	  && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
+      || (bitfield && ! flag_signed_bitfields
+	  && (explicit_int || defaulted_int || explicit_char
+	      /* A typedef for plain `int' without `signed'
+		 can be controlled just like plain `int'.  */
+	      || ! (typedef_decl != 0
+		    && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
+	  && TREE_CODE (type) != ENUMERAL_TYPE
+	  && !(specbits & 1 << (int) RID_SIGNED)))
+    {
+      if (longlong)
+	type = long_long_unsigned_type_node;
+      else if (specbits & 1 << (int) RID_LONG)
+	type = long_unsigned_type_node;
+      else if (specbits & 1 << (int) RID_SHORT)
+	type = short_unsigned_type_node;
+      else if (type == char_type_node)
+	type = unsigned_char_type_node;
+      else if (typedef_decl)
+	type = unsigned_type (type);
+      else
+	type = unsigned_type_node;
+    }
+  else if ((specbits & 1 << (int) RID_SIGNED)
+	   && type == char_type_node)
+    type = signed_char_type_node;
+  else if (longlong)
+    type = long_long_integer_type_node;
+  else if (specbits & 1 << (int) RID_LONG)
+    type = long_integer_type_node;
+  else if (specbits & 1 << (int) RID_SHORT)
+    type = short_integer_type_node;
+  else if (specbits & 1 << (int) RID_COMPLEX)
+    {
+      if (defaulted_int)
+	type = complex_double_type_node;
+      else if (type == integer_type_node)
+	type = complex_integer_type_node;
+      else if (type == float_type_node)
+	type = complex_float_type_node;
+      else if (type == double_type_node)
+	type = complex_double_type_node;
+      else if (type == long_double_type_node)
+	type = complex_long_double_type_node;
+      else
+	error ("invalid complex type");
+    }
+
+  /* Set CONSTP if this declaration is `const', whether by
+     explicit specification or via a typedef.
+     Likewise for VOLATILEP.  */
+
+  constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
+  volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
+  inlinep = !! (specbits & (1 << (int) RID_INLINE));
+  if (constp > 1)
+    pedwarn ("duplicate `const'");
+  if (volatilep > 1)
+    pedwarn ("duplicate `volatile'");
+  if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
+    type = TYPE_MAIN_VARIANT (type);
+
+  /* Warn if two storage classes are given. Default to `auto'.  */
+
+  {
+    int nclasses = 0;
+
+    if (specbits & 1 << (int) RID_AUTO) nclasses++;
+    if (specbits & 1 << (int) RID_STATIC) nclasses++;
+    if (specbits & 1 << (int) RID_EXTERN) nclasses++;
+    if (specbits & 1 << (int) RID_REGISTER) nclasses++;
+    if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
+    if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
+
+    /* Warn about storage classes that are invalid for certain
+       kinds of declarations (parameters, typenames, etc.).  */
+
+    if (nclasses > 1)
+      error ("multiple storage classes in declaration of `%s'", name);
+    else if (funcdef_flag
+	     && (specbits
+		 & ((1 << (int) RID_REGISTER)
+		    | (1 << (int) RID_AUTO)
+		    | (1 << (int) RID_TYPEDEF))))
+      {
+	if (specbits & 1 << (int) RID_AUTO
+	    && (pedantic || current_binding_level == global_binding_level))
+	  pedwarn ("function definition declared `auto'");
+	if (specbits & 1 << (int) RID_REGISTER)
+	  error ("function definition declared `register'");
+	if (specbits & 1 << (int) RID_TYPEDEF)
+	  error ("function definition declared `typedef'");
+	specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
+		       | (1 << (int) RID_AUTO));
+      }
+    else if (decl_context != NORMAL && nclasses > 0)
+      {
+	if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
+	  ;
+	else
+	  {
+	    error ((decl_context == FIELD
+		    ? "storage class specified for structure field `%s'"
+		    : (decl_context == PARM
+		       ? "storage class specified for parameter `%s'"
+		       : "storage class specified for typename")),
+		   name);
+	    specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
+			   | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
+			   | (1 << (int) RID_EXTERN));
+	  }
+      }
+    else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
+      {
+	/* `extern' with initialization is invalid if not at top level.  */
+	if (current_binding_level == global_binding_level)
+	  warning ("`%s' initialized and declared `extern'", name);
+	else
+	  error ("`%s' has both `extern' and initializer", name);
+      }
+    else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
+	     && current_binding_level != global_binding_level)
+      error ("nested function `%s' declared `extern'", name);
+    else if (current_binding_level == global_binding_level
+	     && specbits & (1 << (int) RID_AUTO))
+      error ("top-level declaration of `%s' specifies `auto'", name);
+    else if ((specbits & 1 << (int) RID_ITERATOR)
+	     && TREE_CODE (declarator) != IDENTIFIER_NODE)
+      {
+	error ("iterator `%s' has derived type", name);
+	type = error_mark_node;
+      }
+    else if ((specbits & 1 << (int) RID_ITERATOR)
+	     && TREE_CODE (type) != INTEGER_TYPE)
+      {
+	error ("iterator `%s' has noninteger type", name);
+	type = error_mark_node;
+      }
+  }
+
+  /* Now figure out the structure of the declarator proper.
+     Descend through it, creating more complex types, until we reach
+     the declared identifier (or NULL_TREE, in an absolute declarator).  */
+
+  while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
+    {
+      if (type == error_mark_node)
+	{
+	  declarator = TREE_OPERAND (declarator, 0);
+	  continue;
+	}
+
+      /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
+	 an INDIRECT_REF (for *...),
+	 a CALL_EXPR (for ...(...)),
+	 an identifier (for the name being declared)
+	 or a null pointer (for the place in an absolute declarator
+	 where the name was omitted).
+	 For the last two cases, we have just exited the loop.
+
+	 At this point, TYPE is the type of elements of an array,
+	 or for a function to return, or for a pointer to point to.
+	 After this sequence of ifs, TYPE is the type of the
+	 array or function or pointer, and DECLARATOR has had its
+	 outermost layer removed.  */
+
+      if (TREE_CODE (declarator) == ARRAY_REF)
+	{
+	  register tree itype = NULL_TREE;
+	  register tree size = TREE_OPERAND (declarator, 1);
+	  /* An uninitialized decl with `extern' is a reference.  */
+	  int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
+
+	  declarator = TREE_OPERAND (declarator, 0);
+
+	  /* Check for some types that there cannot be arrays of.  */
+
+	  if (TYPE_MAIN_VARIANT (type) == void_type_node)
+	    {
+	      error ("declaration of `%s' as array of voids", name);
+	      type = error_mark_node;
+	    }
+
+	  if (TREE_CODE (type) == FUNCTION_TYPE)
+	    {
+	      error ("declaration of `%s' as array of functions", name);
+	      type = error_mark_node;
+	    }
+
+	  if (size == error_mark_node)
+	    type = error_mark_node;
+
+	  if (type == error_mark_node)
+	    continue;
+
+	  /* If this is a block level extern, it must live past the end
+	     of the function so that we can check it against other extern
+	     declarations (IDENTIFIER_LIMBO_VALUE).  */
+	  if (extern_ref && allocation_temporary_p ())
+	    end_temporary_allocation ();
+
+	  /* If size was specified, set ITYPE to a range-type for that size.
+	     Otherwise, ITYPE remains null.  finish_decl may figure it out
+	     from an initial value.  */
+
+	  if (size)
+	    {
+	      /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+	      STRIP_TYPE_NOPS (size);
+
+	      if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
+		  && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
+		{
+		  error ("size of array `%s' has non-integer type", name);
+		  size = integer_one_node;
+		}
+	      if (pedantic && integer_zerop (size))
+		pedwarn ("ANSI C forbids zero-size array `%s'", name);
+	      if (TREE_CODE (size) == INTEGER_CST)
+		{
+		  constant_expression_warning (size);
+		  if (INT_CST_LT (size, integer_zero_node))
+		    {
+		      error ("size of array `%s' is negative", name);
+		      size = integer_one_node;
+		    }
+		  itype = build_index_type (size_binop (MINUS_EXPR, size,
+							size_one_node));
+		}
+	      else
+		{
+		  if (pedantic)
+		    {
+		      if (TREE_CONSTANT (size))
+			pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
+		      else
+			pedwarn ("ANSI C forbids variable-size array `%s'", name);
+		    }
+		  itype = build_binary_op (MINUS_EXPR, size, integer_one_node,
+					   1);
+		  /* Make sure the array size remains visibly nonconstant
+		     even if it is (eg) a const variable with known value.  */
+		  size_varies = 1;
+		  itype = variable_size (itype);
+		  itype = build_index_type (itype);
+		}
+	    }
+
+#if 0 /* This had bad results for pointers to arrays, as in
+	 union incomplete (*foo)[4];  */
+	  /* Complain about arrays of incomplete types, except in typedefs.  */
+
+	  if (TYPE_SIZE (type) == 0
+	      /* Avoid multiple warnings for nested array types.  */
+	      && TREE_CODE (type) != ARRAY_TYPE
+	      && !(specbits & (1 << (int) RID_TYPEDEF))
+	      && !C_TYPE_BEING_DEFINED (type))
+	    warning ("array type has incomplete element type");
+#endif
+
+#if 0  /* We shouldn't have a function type here at all!
+	  Functions aren't allowed as array elements.  */
+	  if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
+	      && (constp || volatilep))
+	    pedwarn ("ANSI C forbids const or volatile function types");
+#endif
+
+	  /* Build the array type itself, then merge any constancy or
+	     volatility into the target type.  We must do it in this order
+	     to ensure that the TYPE_MAIN_VARIANT field of the array type
+	     is set correctly.  */
+
+	  type = build_array_type (type, itype);
+	  if (constp || volatilep)
+	    type = c_build_type_variant (type, constp, volatilep);
+
+#if 0	/* don't clear these; leave them set so that the array type
+	   or the variable is itself const or volatile.  */
+	  constp = 0;
+	  volatilep = 0;
+#endif
+
+	  if (size_varies)
+	    C_TYPE_VARIABLE_SIZE (type) = 1;
+	}
+      else if (TREE_CODE (declarator) == CALL_EXPR)
+	{
+	  int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
+			    || current_binding_level == global_binding_level);
+	  tree arg_types;
+
+	  /* Declaring a function type.
+	     Make sure we have a valid type for the function to return.  */
+	  if (type == error_mark_node)
+	    continue;
+
+	  size_varies = 0;
+
+	  /* Warn about some types functions can't return.  */
+
+	  if (TREE_CODE (type) == FUNCTION_TYPE)
+	    {
+	      error ("`%s' declared as function returning a function", name);
+	      type = integer_type_node;
+	    }
+	  if (TREE_CODE (type) == ARRAY_TYPE)
+	    {
+	      error ("`%s' declared as function returning an array", name);
+	      type = integer_type_node;
+	    }
+
+#ifndef TRADITIONAL_RETURN_FLOAT
+	  /* Traditionally, declaring return type float means double.  */
+
+	  if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
+	    type = double_type_node;
+#endif /* TRADITIONAL_RETURN_FLOAT */
+
+	  /* If this is a block level extern, it must live past the end
+	     of the function so that we can check it against other extern
+	     declarations (IDENTIFIER_LIMBO_VALUE).  */
+	  if (extern_ref && allocation_temporary_p ())
+	    end_temporary_allocation ();
+
+	  /* Construct the function type and go to the next
+	     inner layer of declarator.  */
+
+	  arg_types = grokparms (TREE_OPERAND (declarator, 1),
+				 funcdef_flag
+				 /* Say it's a definition
+				    only for the CALL_EXPR
+				    closest to the identifier.  */
+				 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
+#if 0 /* This seems to be false.  We turn off temporary allocation
+	 above in this function if -traditional.
+	 And this code caused inconsistent results with prototypes:
+	 callers would ignore them, and pass arguments wrong.  */
+
+	  /* Omit the arg types if -traditional, since the arg types
+	     and the list links might not be permanent.  */
+	  type = build_function_type (type,
+				      flag_traditional 
+				      ? NULL_TREE : arg_types);
+#endif
+	  type = build_function_type (type, arg_types);
+	  declarator = TREE_OPERAND (declarator, 0);
+
+	  /* Set the TYPE_CONTEXTs for each tagged type which is local to
+	     the formal parameter list of this FUNCTION_TYPE to point to
+	     the FUNCTION_TYPE node itself.  */
+
+	  {
+	    register tree link;
+
+	    for (link = current_function_parm_tags;
+		 link;
+		 link = TREE_CHAIN (link))
+	      TYPE_CONTEXT (TREE_VALUE (link)) = type;
+	  }
+	}
+      else if (TREE_CODE (declarator) == INDIRECT_REF)
+	{
+	  /* Merge any constancy or volatility into the target type
+	     for the pointer.  */
+
+	  if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
+	      && (constp || volatilep))
+	    pedwarn ("ANSI C forbids const or volatile function types");
+	  if (constp || volatilep)
+	    type = c_build_type_variant (type, constp, volatilep);
+	  constp = 0;
+	  volatilep = 0;
+	  size_varies = 0;
+
+	  type = build_pointer_type (type);
+
+	  /* Process a list of type modifier keywords
+	     (such as const or volatile) that were given inside the `*'.  */
+
+	  if (TREE_TYPE (declarator))
+	    {
+	      register tree typemodlist;
+	      int erred = 0;
+	      for (typemodlist = TREE_TYPE (declarator); typemodlist;
+		   typemodlist = TREE_CHAIN (typemodlist))
+		{
+		  if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
+		    constp++;
+		  else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
+		    volatilep++;
+		  else if (!erred)
+		    {
+		      erred = 1;
+		      error ("invalid type modifier within pointer declarator");
+		    }
+		}
+	      if (constp > 1)
+		pedwarn ("duplicate `const'");
+	      if (volatilep > 1)
+		pedwarn ("duplicate `volatile'");
+	    }
+
+	  declarator = TREE_OPERAND (declarator, 0);
+	}
+      else
+	abort ();
+
+    }
+
+  /* Now TYPE has the actual type.  */
+
+  /* If this is declaring a typedef name, return a TYPE_DECL.  */
+
+  if (specbits & (1 << (int) RID_TYPEDEF))
+    {
+      tree decl;
+      /* Note that the grammar rejects storage classes
+	 in typenames, fields or parameters */
+      if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
+	  && (constp || volatilep))
+	pedwarn ("ANSI C forbids const or volatile function types");
+      if (constp || volatilep)
+	type = c_build_type_variant (type, constp, volatilep);
+      pop_obstacks ();
+      decl = build_decl (TYPE_DECL, declarator, type);
+      if ((specbits & (1 << (int) RID_SIGNED))
+	  || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
+	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
+      return decl;
+    }
+
+  /* Detect the case of an array type of unspecified size
+     which came, as such, direct from a typedef name.
+     We must copy the type, so that each identifier gets
+     a distinct type, so that each identifier's size can be
+     controlled separately by its own initializer.  */
+
+  if (type != 0 && typedef_type != 0
+      && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
+      && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
+    {
+      type = build_array_type (TREE_TYPE (type), 0);
+      if (size_varies)
+	C_TYPE_VARIABLE_SIZE (type) = 1;
+    }
+
+  /* If this is a type name (such as, in a cast or sizeof),
+     compute the type and return it now.  */
+
+  if (decl_context == TYPENAME)
+    {
+      /* Note that the grammar rejects storage classes
+	 in typenames, fields or parameters */
+      if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
+	  && (constp || volatilep))
+	pedwarn ("ANSI C forbids const or volatile function types");
+      if (constp || volatilep)
+	type = c_build_type_variant (type, constp, volatilep);
+      pop_obstacks ();
+      return type;
+    }
+
+  /* `void' at top level (not within pointer)
+     is allowed only in typedefs or type names.
+     We don't complain about parms either, but that is because
+     a better error message can be made later.  */
+
+  if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM)
+    {
+      error ("variable or field `%s' declared void",
+	     IDENTIFIER_POINTER (declarator));
+      type = integer_type_node;
+    }
+
+  /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
+     or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
+
+  {
+    register tree decl;
+
+    if (decl_context == PARM)
+      {
+	tree type_as_written = type;
+	tree main_type;
+
+	/* A parameter declared as an array of T is really a pointer to T.
+	   One declared as a function is really a pointer to a function.  */
+
+	if (TREE_CODE (type) == ARRAY_TYPE)
+	  {
+	    /* Transfer const-ness of array into that of type pointed to.  */
+	    type = build_pointer_type
+		    (c_build_type_variant (TREE_TYPE (type), constp, volatilep));
+	    volatilep = constp = 0;
+	    size_varies = 0;
+	  }
+	else if (TREE_CODE (type) == FUNCTION_TYPE)
+	  {
+	    if (pedantic && (constp || volatilep))
+	      pedwarn ("ANSI C forbids const or volatile function types");
+	    type = build_pointer_type (c_build_type_variant (type, constp, volatilep));
+	    volatilep = constp = 0;
+	  }
+
+	decl = build_decl (PARM_DECL, declarator, type);
+	if (size_varies)
+	  C_DECL_VARIABLE_SIZE (decl) = 1;
+
+	/* Compute the type actually passed in the parmlist,
+	   for the case where there is no prototype.
+	   (For example, shorts and chars are passed as ints.)
+	   When there is a prototype, this is overridden later.  */
+
+	DECL_ARG_TYPE (decl) = type;
+	main_type = (type == error_mark_node
+		     ? error_mark_node
+		     : TYPE_MAIN_VARIANT (type));
+	if (main_type == float_type_node)
+	  DECL_ARG_TYPE (decl) = double_type_node;
+	/* Don't use TYPE_PRECISION to decide whether to promote,
+	   because we should convert short if it's the same size as int,
+	   but we should not convert long if it's the same size as int.  */
+	else if (TREE_CODE (main_type) != ERROR_MARK
+		 && C_PROMOTING_INTEGER_TYPE_P (main_type))
+	  {
+	    if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
+		&& TREE_UNSIGNED (type))
+	      DECL_ARG_TYPE (decl) = unsigned_type_node;
+	    else
+	      DECL_ARG_TYPE (decl) = integer_type_node;
+	  }
+
+	DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
+      }
+    else if (decl_context == FIELD)
+      {
+	/* Structure field.  It may not be a function.  */
+
+	if (TREE_CODE (type) == FUNCTION_TYPE)
+	  {
+	    error ("field `%s' declared as a function",
+		   IDENTIFIER_POINTER (declarator));
+	    type = build_pointer_type (type);
+	  }
+	else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
+	  {
+	    error ("field `%s' has incomplete type",
+		   IDENTIFIER_POINTER (declarator));
+	    type = error_mark_node;
+	  }
+	/* Move type qualifiers down to element of an array.  */
+	if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
+	  {
+	    type = build_array_type (c_build_type_variant (TREE_TYPE (type),
+							   constp, volatilep),
+				     TYPE_DOMAIN (type));
+#if 0 /* Leave the field const or volatile as well.  */
+	    constp = volatilep = 0;
+#endif
+	  }
+	decl = build_decl (FIELD_DECL, declarator, type);
+	if (size_varies)
+	  C_DECL_VARIABLE_SIZE (decl) = 1;
+      }
+    else if (TREE_CODE (type) == FUNCTION_TYPE)
+      {
+	/* Every function declaration is "external"
+	   except for those which are inside a function body
+	   in which `auto' is used.
+	   That is a case not specified by ANSI C,
+	   and we use it for forward declarations for nested functions.  */
+	int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
+			  || current_binding_level == global_binding_level);
+
+	if (specbits & (1 << (int) RID_AUTO)
+	    && (pedantic || current_binding_level == global_binding_level))
+	  pedwarn ("invalid storage class for function `%s'",
+		 IDENTIFIER_POINTER (declarator));
+	if (specbits & (1 << (int) RID_REGISTER))
+	  error ("invalid storage class for function `%s'",
+		 IDENTIFIER_POINTER (declarator));
+	/* Function declaration not at top level.
+	   Storage classes other than `extern' are not allowed
+	   and `extern' makes no difference.  */
+	if (current_binding_level != global_binding_level
+	    && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
+	    && pedantic)
+	  pedwarn ("invalid storage class for function `%s'",
+		   IDENTIFIER_POINTER (declarator));
+
+	/* If this is a block level extern, it must live past the end
+	   of the function so that we can check it against other
+	   extern declarations (IDENTIFIER_LIMBO_VALUE).  */
+	if (extern_ref && allocation_temporary_p ())
+	  end_temporary_allocation ();
+
+	decl = build_decl (FUNCTION_DECL, declarator, type);
+
+	if (pedantic && (constp || volatilep)
+	    && ! DECL_IN_SYSTEM_HEADER (decl))
+	  pedwarn ("ANSI C forbids const or volatile functions");
+
+	if (extern_ref)
+	  DECL_EXTERNAL (decl) = 1;
+	/* Record absence of global scope for `static' or `auto'.  */
+	TREE_PUBLIC (decl)
+	  = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
+	/* Record presence of `inline', if it is reasonable.  */
+	if (inlinep)
+	  {
+	    tree last = tree_last (TYPE_ARG_TYPES (type));
+
+	    if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
+	      warning ("cannot inline function `main'");
+	    else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last))
+			      != void_type_node))
+	      warning ("inline declaration ignored for function with `...'");
+	    else
+	      /* Assume that otherwise the function can be inlined.  */
+	      DECL_INLINE (decl) = 1;
+
+	    if (specbits & (1 << (int) RID_EXTERN))
+	      current_extern_inline = 1;
+	  }
+      }
+    else
+      {
+	/* It's a variable.  */
+	/* An uninitialized decl with `extern' is a reference.  */
+	int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
+
+	/* Move type qualifiers down to element of an array.  */
+	if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
+	  {
+	    type = build_array_type (c_build_type_variant (TREE_TYPE (type),
+							   constp, volatilep),
+				     TYPE_DOMAIN (type));
+#if 0 /* Leave the variable const or volatile as well.  */
+	    constp = volatilep = 0;
+#endif
+	  }
+
+	/* If this is a block level extern, it must live past the end
+	   of the function so that we can check it against other
+	   extern declarations (IDENTIFIER_LIMBO_VALUE).  */
+	if (extern_ref && allocation_temporary_p ())
+	  end_temporary_allocation ();
+
+	decl = build_decl (VAR_DECL, declarator, type);
+	if (size_varies)
+	  C_DECL_VARIABLE_SIZE (decl) = 1;
+
+	if (inlinep)
+	  pedwarn_with_decl (decl, "variable `%s' declared `inline'");
+
+	DECL_EXTERNAL (decl) = extern_ref;
+	/* At top level, the presence of a `static' or `register' storage
+	   class specifier, or the absence of all storage class specifiers
+	   makes this declaration a definition (perhaps tentative).  Also,
+	   the absence of both `static' and `register' makes it public.  */
+	if (current_binding_level == global_binding_level)
+	  {
+	    TREE_PUBLIC (decl)
+	      = !(specbits
+		  & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
+	    TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
+	  }
+	/* Not at top level, only `static' makes a static definition.  */
+	else
+	  {
+	    TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
+	    TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
+	  }
+
+	if (specbits & 1 << (int) RID_ITERATOR)
+	  ITERATOR_P (decl) = 1;
+      }
+
+    /* Record `register' declaration for warnings on &
+       and in case doing stupid register allocation.  */
+
+    if (specbits & (1 << (int) RID_REGISTER))
+      DECL_REGISTER (decl) = 1;
+
+    /* Record constancy and volatility.  */
+
+    if (constp)
+      TREE_READONLY (decl) = 1;
+    if (volatilep)
+      {
+	TREE_SIDE_EFFECTS (decl) = 1;
+	TREE_THIS_VOLATILE (decl) = 1;
+      }
+    /* If a type has volatile components, it should be stored in memory.
+       Otherwise, the fact that those components are volatile
+       will be ignored, and would even crash the compiler.  */
+    if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
+      mark_addressable (decl);
+
+    pop_obstacks ();
+
+    return decl;
+  }
+}
+
+/* Decode the parameter-list info for a function type or function definition.
+   The argument is the value returned by `get_parm_info' (or made in parse.y
+   if there is an identifier list instead of a parameter decl list).
+   These two functions are separate because when a function returns
+   or receives functions then each is called multiple times but the order
+   of calls is different.  The last call to `grokparms' is always the one
+   that contains the formal parameter names of a function definition.
+
+   Store in `last_function_parms' a chain of the decls of parms.
+   Also store in `last_function_parm_tags' a chain of the struct, union,
+   and enum tags declared among the parms.
+
+   Return a list of arg types to use in the FUNCTION_TYPE for this function.
+
+   FUNCDEF_FLAG is nonzero for a function definition, 0 for
+   a mere declaration.  A nonempty identifier-list gets an error message
+   when FUNCDEF_FLAG is zero.  */
+
+static tree
+grokparms (parms_info, funcdef_flag)
+     tree parms_info;
+     int funcdef_flag;
+{
+  tree first_parm = TREE_CHAIN (parms_info);
+
+  last_function_parms = TREE_PURPOSE (parms_info);
+  last_function_parm_tags = TREE_VALUE (parms_info);
+
+  if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
+      && !in_system_header)
+    warning ("function declaration isn't a prototype");
+
+  if (first_parm != 0
+      && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
+    {
+      if (! funcdef_flag)
+	pedwarn ("parameter names (without types) in function declaration");
+
+      last_function_parms = first_parm;
+      return 0;
+    }
+  else
+    {
+      tree parm;
+      tree typelt;
+      /* We no longer test FUNCDEF_FLAG.
+	 If the arg types are incomplete in a declaration,
+	 they must include undefined tags.
+	 These tags can never be defined in the scope of the declaration,
+	 so the types can never be completed,
+	 and no call can be compiled successfully.  */
+#if 0
+      /* In a fcn definition, arg types must be complete.  */
+      if (funcdef_flag)
+#endif
+	for (parm = last_function_parms, typelt = first_parm;
+	     parm;
+	     parm = TREE_CHAIN (parm))
+	  /* Skip over any enumeration constants declared here.  */
+	  if (TREE_CODE (parm) == PARM_DECL)
+	    {
+	      /* Barf if the parameter itself has an incomplete type.  */
+	      tree type = TREE_VALUE (typelt);
+	      if (TYPE_SIZE (type) == 0)
+		{
+		  if (funcdef_flag && DECL_NAME (parm) != 0)
+		    error ("parameter `%s' has incomplete type",
+			   IDENTIFIER_POINTER (DECL_NAME (parm)));
+		  else
+		    warning ("parameter has incomplete type");
+		  if (funcdef_flag)
+		    {
+		      TREE_VALUE (typelt) = error_mark_node;
+		      TREE_TYPE (parm) = error_mark_node;
+		    }
+		}
+#if 0  /* This has been replaced by parm_tags_warning
+	  which uses a more accurate criterion for what to warn about.  */
+	      else
+		{
+		  /* Now warn if is a pointer to an incomplete type.  */
+		  while (TREE_CODE (type) == POINTER_TYPE
+			 || TREE_CODE (type) == REFERENCE_TYPE)
+		    type = TREE_TYPE (type);
+		  type = TYPE_MAIN_VARIANT (type);
+		  if (TYPE_SIZE (type) == 0)
+		    {
+		      if (DECL_NAME (parm) != 0)
+			warning ("parameter `%s' points to incomplete type",
+				 IDENTIFIER_POINTER (DECL_NAME (parm)));
+		      else
+			warning ("parameter points to incomplete type");
+		    }
+		}
+#endif
+	      typelt = TREE_CHAIN (typelt);
+	    }
+
+      /* Allocate the list of types the way we allocate a type.  */
+      if (first_parm && ! TREE_PERMANENT (first_parm))
+	{
+	  /* Construct a copy of the list of types
+	     on the saveable obstack.  */
+	  tree result = NULL;
+	  for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
+	    result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
+					 result);
+	  return nreverse (result);
+	}
+      else
+	/* The list we have is permanent already.  */
+	return first_parm;
+    }
+}
+
+
+/* Return a tree_list node with info on a parameter list just parsed.
+   The TREE_PURPOSE is a chain of decls of those parms.
+   The TREE_VALUE is a list of structure, union and enum tags defined.
+   The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
+   This tree_list node is later fed to `grokparms'.
+
+   VOID_AT_END nonzero means append `void' to the end of the type-list.
+   Zero means the parmlist ended with an ellipsis so don't append `void'.  */
+
+tree
+get_parm_info (void_at_end)
+     int void_at_end;
+{
+  register tree decl, t;
+  register tree types = 0;
+  int erred = 0;
+  tree tags = gettags ();
+  tree parms = getdecls ();
+  tree new_parms = 0;
+  tree order = current_binding_level->parm_order;
+
+  /* Just `void' (and no ellipsis) is special.  There are really no parms.  */
+  if (void_at_end && parms != 0
+      && TREE_CHAIN (parms) == 0
+      && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
+      && DECL_NAME (parms) == 0)
+    {
+      parms = NULL_TREE;
+      storedecls (NULL_TREE);
+      return saveable_tree_cons (NULL_TREE, NULL_TREE,
+				 saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
+    }
+
+  /* Extract enumerator values and other non-parms declared with the parms.
+     Likewise any forward parm decls that didn't have real parm decls.  */
+  for (decl = parms; decl; )
+    {
+      tree next = TREE_CHAIN (decl);
+
+      if (TREE_CODE (decl) != PARM_DECL)
+	{
+	  TREE_CHAIN (decl) = new_parms;
+	  new_parms = decl;
+	}
+      else if (TREE_ASM_WRITTEN (decl))
+	{
+	  error_with_decl (decl, "parameter `%s' has just a forward declaration");
+	  TREE_CHAIN (decl) = new_parms;
+	  new_parms = decl;
+	}
+      decl = next;
+    }
+
+  /* Put the parm decls back in the order they were in in the parm list.  */
+  for (t = order; t; t = TREE_CHAIN (t))
+    {
+      if (TREE_CHAIN (t))
+	TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
+      else
+	TREE_CHAIN (TREE_VALUE (t)) = 0;
+    }
+
+  new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
+		       new_parms);
+
+  /* Store the parmlist in the binding level since the old one
+     is no longer a valid list.  (We have changed the chain pointers.)  */
+  storedecls (new_parms);
+
+  for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
+    /* There may also be declarations for enumerators if an enumeration
+       type is declared among the parms.  Ignore them here.  */
+    if (TREE_CODE (decl) == PARM_DECL)
+      {
+	/* Since there is a prototype,
+	   args are passed in their declared types.  */
+	tree type = TREE_TYPE (decl);
+	DECL_ARG_TYPE (decl) = type;
+#ifdef PROMOTE_PROTOTYPES
+	if (TREE_CODE (type) == INTEGER_TYPE
+	    && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
+	  DECL_ARG_TYPE (decl) = integer_type_node;
+#endif
+
+	types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
+	if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
+	    && DECL_NAME (decl) == 0)
+	  {
+	    error ("`void' in parameter list must be the entire list");
+	    erred = 1;
+	  }
+      }
+
+  if (void_at_end)
+    return saveable_tree_cons (new_parms, tags,
+			       nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
+
+  return saveable_tree_cons (new_parms, tags, nreverse (types));
+}
+
+/* At end of parameter list, warn about any struct, union or enum tags
+   defined within.  Do so because these types cannot ever become complete.  */
+
+void
+parmlist_tags_warning ()
+{
+  tree elt;
+  static int already;
+
+  for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
+    {
+      enum tree_code code = TREE_CODE (TREE_VALUE (elt));
+      /* An anonymous union parm type is meaningful as a GNU extension.
+	 So don't warn for that.  */
+      if (code == UNION_TYPE && !pedantic)
+	continue;
+      if (TREE_PURPOSE (elt) != 0)
+	warning ("`%s %s' declared inside parameter list",
+		 (code == RECORD_TYPE ? "struct"
+		  : code == UNION_TYPE ? "union"
+		  : "enum"),
+		 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
+      else
+	warning ("anonymous %s declared inside parameter list",
+		 (code == RECORD_TYPE ? "struct"
+		  : code == UNION_TYPE ? "union"
+		  : "enum"));
+
+      if (! already)
+	{
+	  warning ("its scope is only this definition or declaration,");
+	  warning ("which is probably not what you want.");
+	  already = 1;
+	}
+    }
+}
+
+/* Get the struct, enum or union (CODE says which) with tag NAME.
+   Define the tag as a forward-reference if it is not defined.  */
+
+tree
+xref_tag (code, name)
+     enum tree_code code;
+     tree name;
+{
+  int temporary = allocation_temporary_p ();
+
+  /* If a cross reference is requested, look up the type
+     already defined for this tag and return it.  */
+
+  register tree ref = lookup_tag (code, name, current_binding_level, 0);
+  /* Even if this is the wrong type of tag, return what we found.
+     There will be an error message anyway, from pending_xref_error.
+     If we create an empty xref just for an invalid use of the type,
+     the main result is to create lots of superfluous error messages.  */
+  if (ref)
+    return ref;
+
+  push_obstacks_nochange ();
+
+  if (current_binding_level == global_binding_level && temporary)
+    end_temporary_allocation ();
+
+  /* If no such tag is yet defined, create a forward-reference node
+     and record it as the "definition".
+     When a real declaration of this type is found,
+     the forward-reference will be altered into a real type.  */
+
+  ref = make_node (code);
+  if (code == ENUMERAL_TYPE)
+    {
+      /* (In ANSI, Enums can be referred to only if already defined.)  */
+      if (pedantic)
+	pedwarn ("ANSI C forbids forward references to `enum' types");
+      /* Give the type a default layout like unsigned int
+	 to avoid crashing if it does not get defined.  */
+      TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
+      TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
+      TREE_UNSIGNED (ref) = 1;
+      TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
+      TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
+      TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
+    }
+
+  pushtag (name, ref);
+
+  pop_obstacks ();
+
+  return ref;
+}
+
+/* Make sure that the tag NAME is defined *in the current binding level*
+   at least as a forward reference.
+   CODE says which kind of tag NAME ought to be.
+
+   We also do a push_obstacks_nochange
+   whose matching pop is in finish_struct.  */
+
+tree
+start_struct (code, name)
+     enum tree_code code;
+     tree name;
+{
+  /* If there is already a tag defined at this binding level
+     (as a forward reference), just return it.  */
+
+  register tree ref = 0;
+
+  push_obstacks_nochange ();
+  if (current_binding_level == global_binding_level)
+    end_temporary_allocation ();
+
+  if (name != 0)
+    ref = lookup_tag (code, name, current_binding_level, 1);
+  if (ref && TREE_CODE (ref) == code)
+    {
+      C_TYPE_BEING_DEFINED (ref) = 1;
+      if (TYPE_FIELDS (ref))
+	error ((code == UNION_TYPE ? "redefinition of `union %s'"
+		: "redefinition of `struct %s'"),
+	       IDENTIFIER_POINTER (name));
+
+      return ref;
+    }
+
+  /* Otherwise create a forward-reference just so the tag is in scope.  */
+
+  ref = make_node (code);
+  pushtag (name, ref);
+  C_TYPE_BEING_DEFINED (ref) = 1;
+  return ref;
+}
+
+/* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
+   of a structure component, returning a FIELD_DECL node.
+   WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
+
+   This is done during the parsing of the struct declaration.
+   The FIELD_DECL nodes are chained together and the lot of them
+   are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
+
+tree
+grokfield (filename, line, declarator, declspecs, width)
+     char *filename;
+     int line;
+     tree declarator, declspecs, width;
+{
+  tree value;
+
+  /* The corresponding pop_obstacks is in finish_decl.  */
+  push_obstacks_nochange ();
+
+  value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
+
+  finish_decl (value, NULL_TREE, NULL_TREE);
+  DECL_INITIAL (value) = width;
+
+  maybe_objc_check_decl (value);
+  return value;
+}
+
+/* Function to help qsort sort FIELD_DECLs by name order.  */
+
+static int
+field_decl_cmp (x, y)
+     tree *x, *y;
+{
+  return (long)DECL_NAME (*x) - (long)DECL_NAME (*y);
+}
+
+/* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
+   FIELDLIST is a chain of FIELD_DECL nodes for the fields.
+
+   We also do a pop_obstacks to match the push in start_struct.  */
+
+tree
+finish_struct (t, fieldlist)
+     register tree t, fieldlist;
+{
+  register tree x;
+  int old_momentary;
+  int toplevel = global_binding_level == current_binding_level;
+
+  /* If this type was previously laid out as a forward reference,
+     make sure we lay it out again.  */
+
+  TYPE_SIZE (t) = 0;
+
+  /* Nameless union parm types are useful as GCC extension.  */
+  if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
+    /* Otherwise, warn about any struct or union def. in parmlist.  */
+    if (in_parm_level_p ())
+      {
+	if (pedantic)
+	  pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
+		    : "structure defined inside parms"));
+	else if (! flag_traditional)
+	  warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
+		    : "structure defined inside parms"));
+      }
+
+  old_momentary = suspend_momentary ();
+
+  if (fieldlist == 0 && pedantic)
+    pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union has no members"
+	      : "structure has no members"));
+
+  /* Install struct as DECL_CONTEXT of each field decl.
+     Also process specified field sizes.
+     Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
+     The specified size is found in the DECL_INITIAL.
+     Store 0 there, except for ": 0" fields (so we can find them
+     and delete them, below).  */
+
+  for (x = fieldlist; x; x = TREE_CHAIN (x))
+    {
+      DECL_CONTEXT (x) = t;
+      DECL_FIELD_SIZE (x) = 0;
+
+      /* If any field is const, the structure type is pseudo-const.  */
+      if (TREE_READONLY (x))
+	C_TYPE_FIELDS_READONLY (t) = 1;
+      else
+	{
+	  /* A field that is pseudo-const makes the structure likewise.  */
+	  tree t1 = TREE_TYPE (x);
+	  while (TREE_CODE (t1) == ARRAY_TYPE)
+	    t1 = TREE_TYPE (t1);
+	  if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
+	      && C_TYPE_FIELDS_READONLY (t1))
+	    C_TYPE_FIELDS_READONLY (t) = 1;
+	}
+
+      /* Any field that is volatile means variables of this type must be
+	 treated in some ways as volatile.  */
+      if (TREE_THIS_VOLATILE (x))
+	C_TYPE_FIELDS_VOLATILE (t) = 1;
+
+      /* Any field of nominal variable size implies structure is too.  */
+      if (C_DECL_VARIABLE_SIZE (x))
+	C_TYPE_VARIABLE_SIZE (t) = 1;
+
+      /* Detect invalid nested redefinition.  */
+      if (TREE_TYPE (x) == t)
+	error ("nested redefinition of `%s'",
+	       IDENTIFIER_POINTER (TYPE_NAME (t)));
+
+      /* Detect invalid bit-field size.  */
+      if (DECL_INITIAL (x))
+	STRIP_NOPS (DECL_INITIAL (x));
+      if (DECL_INITIAL (x))
+	{
+	  if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
+	    constant_expression_warning (DECL_INITIAL (x));
+	  else
+	    {
+	      error_with_decl (x, "bit-field `%s' width not an integer constant");
+	      DECL_INITIAL (x) = NULL;
+	    }
+	}
+
+      /* Detect invalid bit-field type.  */
+      if (DECL_INITIAL (x)
+	  && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
+	  && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
+	{
+	  error_with_decl (x, "bit-field `%s' has invalid type");
+	  DECL_INITIAL (x) = NULL;
+	}
+      if (DECL_INITIAL (x) && pedantic
+	  && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
+	  && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node)
+	pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
+
+      /* Detect and ignore out of range field width.  */
+      if (DECL_INITIAL (x))
+	{
+	  unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
+
+	  if (tree_int_cst_lt (DECL_INITIAL (x), integer_zero_node))
+	    {
+	      DECL_INITIAL (x) = NULL;
+	      error_with_decl (x, "negative width in bit-field `%s'");
+	    }
+	  else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
+		   || width > TYPE_PRECISION (TREE_TYPE (x)))
+	    {
+	      DECL_INITIAL (x) = NULL;
+	      pedwarn_with_decl (x, "width of `%s' exceeds its type");
+	    }
+	  else if (width == 0 && DECL_NAME (x) != 0)
+	    {
+	      error_with_decl (x, "zero width for bit-field `%s'");
+	      DECL_INITIAL (x) = NULL;
+	    }
+	}
+
+      /* Process valid field width.  */
+      if (DECL_INITIAL (x))
+	{
+	  register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
+
+	  DECL_FIELD_SIZE (x) = width;
+	  DECL_BIT_FIELD (x) = 1;
+	  DECL_INITIAL (x) = NULL;
+
+	  if (width == 0)
+	    {
+	      /* field size 0 => force desired amount of alignment.  */
+#ifdef EMPTY_FIELD_BOUNDARY
+	      DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
+#endif
+#ifdef PCC_BITFIELD_TYPE_MATTERS
+	      DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
+				    TYPE_ALIGN (TREE_TYPE (x)));
+#endif
+	    }
+	}
+      else
+	{
+	  int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
+			   : TYPE_ALIGN (TREE_TYPE (x)));
+	  /* Non-bit-fields are aligned for their type, except packed
+	     fields which require only BITS_PER_UNIT alignment.  */
+	  DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
+	}
+    }
+
+  /* Now DECL_INITIAL is null on all members.  */
+
+  /* Delete all duplicate fields from the fieldlist */
+  for (x = fieldlist; x && TREE_CHAIN (x);)
+    /* Anonymous fields aren't duplicates.  */
+    if (DECL_NAME (TREE_CHAIN (x)) == 0)
+      x = TREE_CHAIN (x);
+    else
+      {
+	register tree y = fieldlist;
+	  
+	while (1)
+	  {
+	    if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
+	      break;
+	    if (y == x)
+	      break;
+	    y = TREE_CHAIN (y);
+	  }
+	if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
+	  {
+	    error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
+	    TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
+	  }
+	else x = TREE_CHAIN (x);
+      }
+
+  /* Now we have the nearly final fieldlist.  Record it,
+     then lay out the structure or union (including the fields).  */
+
+  TYPE_FIELDS (t) = fieldlist;
+
+  layout_type (t);
+
+  /* Delete all zero-width bit-fields from the front of the fieldlist */
+  while (fieldlist
+	 && DECL_INITIAL (fieldlist))
+    fieldlist = TREE_CHAIN (fieldlist);
+  /* Delete all such members from the rest of the fieldlist */
+  for (x = fieldlist; x;)
+    {
+      if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
+	TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
+      else x = TREE_CHAIN (x);
+    }
+
+  /*  Now we have the truly final field list.
+      Store it in this type and in the variants.  */
+
+  TYPE_FIELDS (t) = fieldlist;
+
+  /* If there are lots of fields, sort so we can look through them fast.
+     We arbitrarily consider 16 or more elts to be "a lot".  */
+  {
+    int len = 0;
+
+    for (x = fieldlist; x; x = TREE_CHAIN (x))
+      {
+	if (len > 15)
+	  break;
+	len += 1;
+      }
+    if (len > 15)
+      {
+	tree *field_array;
+	char *space;
+
+	len += list_length (x);
+	/* Use the same allocation policy here that make_node uses, to
+	   ensure that this lives as long as the rest of the struct decl.
+	   All decls in an inline function need to be saved.  */
+	if (allocation_temporary_p ())
+	  space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
+	else
+	  space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
+
+	TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
+	TYPE_LANG_SPECIFIC (t)->len = len;
+
+	field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
+	len = 0;
+	for (x = fieldlist; x; x = TREE_CHAIN (x))
+	  field_array[len++] = x;
+
+	qsort (field_array, len, sizeof (tree), field_decl_cmp);
+      }
+  }
+
+  for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
+    {
+      TYPE_FIELDS (x) = TYPE_FIELDS (t);
+      TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
+      TYPE_ALIGN (x) = TYPE_ALIGN (t);
+    }
+
+  /* Promote each bit-field's type to int if it is narrower than that.  */
+  for (x = fieldlist; x; x = TREE_CHAIN (x))
+    if (DECL_BIT_FIELD (x)
+	&& (C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x))
+	    || DECL_FIELD_SIZE (x) < TYPE_PRECISION (integer_type_node)))
+      {
+	tree type = TREE_TYPE (x);
+
+	/* Preserve unsignedness if traditional
+	   or if not really getting any wider.  */
+	if (TREE_UNSIGNED (type)
+	    && (flag_traditional
+		||
+		(TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
+		 &&
+		 DECL_FIELD_SIZE (x) == TYPE_PRECISION (integer_type_node))))
+	  TREE_TYPE (x) = unsigned_type_node;
+	else
+	  TREE_TYPE (x) = integer_type_node;
+      }
+
+  /* If this structure or union completes the type of any previous
+     variable declaration, lay it out and output its rtl.  */
+
+  if (current_binding_level->n_incomplete != 0)
+    {
+      tree decl;
+      for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
+	{
+	  if (TREE_TYPE (decl) == t
+	      && TREE_CODE (decl) != TYPE_DECL)
+	    {
+	      layout_decl (decl, 0);
+	      /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
+	      maybe_objc_check_decl (decl);
+	      rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
+	      if (! toplevel)
+		expand_decl (decl);
+	      --current_binding_level->n_incomplete;
+	    }
+	  else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
+		   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
+	    {
+	      tree element = TREE_TYPE (decl);
+	      while (TREE_CODE (element) == ARRAY_TYPE)
+		element = TREE_TYPE (element);
+	      if (element == t)
+		layout_array_type (TREE_TYPE (decl));
+	    }
+	}
+    }
+
+  resume_momentary (old_momentary);
+
+  /* Finish debugging output for this type.  */
+  rest_of_type_compilation (t, toplevel);
+
+  /* The matching push is in start_struct.  */
+  pop_obstacks ();
+
+  return t;
+}
+
+/* Lay out the type T, and its element type, and so on.  */
+
+static void
+layout_array_type (t)
+     tree t;
+{
+  if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
+    layout_array_type (TREE_TYPE (t));
+  layout_type (t);
+}
+
+/* Begin compiling the definition of an enumeration type.
+   NAME is its name (or null if anonymous).
+   Returns the type object, as yet incomplete.
+   Also records info about it so that build_enumerator
+   may be used to declare the individual values as they are read.  */
+
+tree
+start_enum (name)
+     tree name;
+{
+  register tree enumtype = 0;
+
+  /* If this is the real definition for a previous forward reference,
+     fill in the contents in the same object that used to be the
+     forward reference.  */
+
+  if (name != 0)
+    enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
+
+  /* The corresponding pop_obstacks is in finish_enum.  */
+  push_obstacks_nochange ();
+  /* If these symbols and types are global, make them permanent.  */
+  if (current_binding_level == global_binding_level)
+    end_temporary_allocation ();
+
+  if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
+    {
+      enumtype = make_node (ENUMERAL_TYPE);
+      pushtag (name, enumtype);
+    }
+
+  C_TYPE_BEING_DEFINED (enumtype) = 1;
+
+  if (TYPE_VALUES (enumtype) != 0)
+    {
+      /* This enum is a named one that has been declared already.  */
+      error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
+
+      /* Completely replace its old definition.
+	 The old enumerators remain defined, however.  */
+      TYPE_VALUES (enumtype) = 0;
+    }
+
+  enum_next_value = integer_zero_node;
+  enum_overflow = 0;
+
+  return enumtype;
+}
+
+/* After processing and defining all the values of an enumeration type,
+   install their decls in the enumeration type and finish it off.
+   ENUMTYPE is the type object and VALUES a list of decl-value pairs.
+   Returns ENUMTYPE.  */
+
+tree
+finish_enum (enumtype, values)
+     register tree enumtype, values;
+{
+  register tree pair, tem;
+  tree minnode = 0, maxnode = 0;
+  register HOST_WIDE_INT maxvalue = 0;
+  register HOST_WIDE_INT minvalue = 0;
+  register int i;
+  unsigned precision = 0;
+  int toplevel = global_binding_level == current_binding_level;
+  int temporary = allocation_temporary_p ();
+
+  if (in_parm_level_p ())
+    warning ("enum defined inside parms");
+
+  /* Calculate the maximum value of any enumerator in this type.  */
+
+  for (pair = values; pair; pair = TREE_CHAIN (pair))
+    {
+      tree value = TREE_VALUE (pair);
+      if (pair == values)
+	minnode = maxnode = TREE_VALUE (pair);
+      else
+	{
+	  if (tree_int_cst_lt (maxnode, value))
+	    maxnode = value;
+	  if (tree_int_cst_lt (value, minnode))
+	    minnode = value;
+	}
+    }
+
+  TYPE_MIN_VALUE (enumtype) = minnode;
+  TYPE_MAX_VALUE (enumtype) = maxnode;
+
+  /* Determine the precision this type needs.  */
+
+  if (TREE_INT_CST_HIGH (minnode) >= 0
+      ? tree_int_cst_lt (TYPE_MAX_VALUE (unsigned_type_node), maxnode)
+      : (tree_int_cst_lt (minnode, TYPE_MIN_VALUE (integer_type_node))
+	 || tree_int_cst_lt (TYPE_MAX_VALUE (integer_type_node), maxnode)))
+    precision = TYPE_PRECISION (long_long_integer_type_node);
+  else
+    {
+      maxvalue = TREE_INT_CST_LOW (maxnode);
+      minvalue = TREE_INT_CST_LOW (minnode);
+
+      if (maxvalue > 0)
+	precision = floor_log2 (maxvalue) + 1;
+      if (minvalue < 0)
+	{
+	  /* Compute number of bits to represent magnitude of a negative value.
+	     Add one to MINVALUE since range of negative numbers
+	     includes the power of two.  */
+	  unsigned negprecision = floor_log2 (-minvalue - 1) + 1;
+	  if (negprecision > precision)
+	    precision = negprecision;
+	  precision += 1;	/* room for sign bit */
+	}
+
+      if (!precision)
+	precision = 1;
+    }
+
+  if (flag_short_enums || precision > TYPE_PRECISION (integer_type_node))
+    /* Use the width of the narrowest normal C type which is wide enough.  */
+    TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1));
+  else
+    TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
+
+  TYPE_SIZE (enumtype) = 0;
+  layout_type (enumtype);
+
+  /* An enum can have some negative values; then it is signed.  */
+  TREE_UNSIGNED (enumtype) = ! tree_int_cst_lt (minnode, integer_zero_node);
+
+  /* If the enumerators might not fit in an int, change their type now.  */
+  /* It seems more useful in the debugger to leave these as int
+     unless the enumerator is wider than int.  */
+  if (TYPE_PRECISION (enumtype) <= TYPE_PRECISION (integer_type_node))
+    for (pair = values; pair; pair = TREE_CHAIN (pair))
+      {
+	TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
+	DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
+	if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
+	  DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
+      }
+
+  /* Replace the decl nodes in VALUES with their names.  */
+  for (pair = values; pair; pair = TREE_CHAIN (pair))
+    TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
+
+  TYPE_VALUES (enumtype) = values;
+
+  /* Fix up all variant types of this enum type.  */
+  for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
+    {
+      TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
+      TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
+      TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
+      TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
+      TYPE_MODE (tem) = TYPE_MODE (enumtype);
+      TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
+      TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
+      TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
+    }
+
+  /* Finish debugging output for this type.  */
+  rest_of_type_compilation (enumtype, toplevel);
+
+  /* This matches a push in start_enum.  */
+  pop_obstacks ();
+
+  return enumtype;
+}
+
+/* Build and install a CONST_DECL for one value of the
+   current enumeration type (one that was begun with start_enum).
+   Return a tree-list containing the CONST_DECL and its value.
+   Assignment of sequential values by default is handled here.  */
+
+tree
+build_enumerator (name, value)
+     tree name, value;
+{
+  register tree decl;
+
+  /* Validate and default VALUE.  */
+
+  /* Remove no-op casts from the value.  */
+  if (value)
+    STRIP_TYPE_NOPS (value);
+
+  if (value != 0)
+    {
+      if (TREE_CODE (value) == INTEGER_CST)
+	constant_expression_warning (value);
+      else
+	{
+	  error ("enumerator value for `%s' not integer constant",
+		 IDENTIFIER_POINTER (name));
+	  value = 0;
+	}
+    }
+
+  /* Default based on previous value.  */
+  /* It should no longer be possible to have NON_LVALUE_EXPR
+     in the default.  */
+  if (value == 0)
+    {
+      value = enum_next_value;
+      if (enum_overflow)
+	error ("overflow in enumeration values");
+    }
+
+  if (pedantic && ! int_fits_type_p (value, integer_type_node))
+    {
+      pedwarn ("ANSI C restricts enumerator values to range of `int'");
+      value = integer_zero_node;
+    }
+
+  /* Set basis for default for next value.  */
+  enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
+  enum_overflow = tree_int_cst_lt (enum_next_value, value);
+
+  /* Now create a declaration for the enum value name.  */
+
+  decl = build_decl (CONST_DECL, name, integer_type_node);
+  DECL_INITIAL (decl) = value;
+  TREE_TYPE (value) = integer_type_node;
+  pushdecl (decl);
+
+  return saveable_tree_cons (decl, value, NULL_TREE);
+}
+
+/* Create the FUNCTION_DECL for a function definition.
+   DECLSPECS and DECLARATOR are the parts of the declaration;
+   they describe the function's name and the type it returns,
+   but twisted together in a fashion that parallels the syntax of C.
+
+   This function creates a binding context for the function body
+   as well as setting up the FUNCTION_DECL in current_function_decl.
+
+   Returns 1 on success.  If the DECLARATOR is not suitable for a function
+   (it defines a datum instead), we return 0, which tells
+   yyparse to report a parse error.
+
+   NESTED is nonzero for a function nested within another function.  */
+
+int
+start_function (declspecs, declarator, nested)
+     tree declarator, declspecs;
+     int nested;
+{
+  tree decl1, old_decl;
+  tree restype;
+
+  current_function_returns_value = 0;  /* Assume, until we see it does. */
+  current_function_returns_null = 0;
+  warn_about_return_type = 0;
+  current_extern_inline = 0;
+  c_function_varargs = 0;
+  named_labels = 0;
+  shadowed_labels = 0;
+
+  decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
+
+  /* If the declarator is not suitable for a function definition,
+     cause a syntax error.  */
+  if (decl1 == 0)
+    return 0;
+
+  announce_function (decl1);
+
+  if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
+    {
+      error ("return-type is an incomplete type");
+      /* Make it return void instead.  */
+      TREE_TYPE (decl1)
+	= build_function_type (void_type_node,
+			       TYPE_ARG_TYPES (TREE_TYPE (decl1)));
+    }
+
+  if (warn_about_return_type)
+    warning ("return-type defaults to `int'");
+
+  /* Save the parm names or decls from this function's declarator
+     where store_parm_decls will find them.  */
+  current_function_parms = last_function_parms;
+  current_function_parm_tags = last_function_parm_tags;
+
+  /* Make the init_value nonzero so pushdecl knows this is not tentative.
+     error_mark_node is replaced below (in poplevel) with the BLOCK.  */
+  DECL_INITIAL (decl1) = error_mark_node;
+
+  /* If this definition isn't a prototype and we had a prototype declaration
+     before, copy the arg type info from that prototype.
+     But not if what we had before was a builtin function.  */
+  old_decl = lookup_name_current_level (DECL_NAME (decl1));
+  if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
+      && !DECL_BUILT_IN (old_decl)
+      && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
+	  == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
+      && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
+    {
+      TREE_TYPE (decl1) = TREE_TYPE (old_decl);
+      current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
+      current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
+    }
+
+  /* Optionally warn of old-fashioned def with no previous prototype.  */
+  if (warn_strict_prototypes
+      && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
+      && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
+    warning ("function declaration isn't a prototype");
+  /* Optionally warn of any global def with no previous prototype.  */
+  else if (warn_missing_prototypes
+	   && TREE_PUBLIC (decl1)
+	   && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
+	   && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
+    warning_with_decl (decl1, "no previous prototype for `%s'");
+  /* Optionally warn of any def with no previous prototype
+     if the function has already been used.  */
+  else if (warn_missing_prototypes
+	   && old_decl != 0 && TREE_USED (old_decl)
+	   && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
+    warning_with_decl (decl1, "`%s' was used with no prototype before its definition");
+
+  /* This is a definition, not a reference.
+     So normally clear DECL_EXTERNAL.
+     However, `extern inline' acts like a declaration
+     except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
+  DECL_EXTERNAL (decl1) = current_extern_inline;
+
+  /* This function exists in static storage.
+     (This does not mean `static' in the C sense!)  */
+  TREE_STATIC (decl1) = 1;
+
+  /* A nested function is not global.  */
+  if (current_function_decl != 0)
+    TREE_PUBLIC (decl1) = 0;
+
+  /* Record the decl so that the function name is defined.
+     If we already have a decl for this name, and it is a FUNCTION_DECL,
+     use the old decl.  */
+
+  current_function_decl = pushdecl (decl1);
+
+  pushlevel (0);
+  declare_parm_level (1);
+  current_binding_level->subblocks_tag_transparent = 1;
+
+  make_function_rtl (current_function_decl);
+
+  restype = TREE_TYPE (TREE_TYPE (current_function_decl));
+  /* Promote the value to int before returning it.  */
+  if (C_PROMOTING_INTEGER_TYPE_P (restype))
+    {
+      /* It retains unsignedness if traditional
+	 or if not really getting wider.  */
+      if (TREE_UNSIGNED (restype)
+	  && (flag_traditional
+	      || (TYPE_PRECISION (restype)
+		  == TYPE_PRECISION (integer_type_node))))
+	restype = unsigned_type_node;
+      else
+	restype = integer_type_node;
+    }
+  DECL_RESULT (current_function_decl)
+    = build_decl (RESULT_DECL, NULL_TREE, restype);
+
+  if (!nested)
+    /* Allocate further tree nodes temporarily during compilation
+       of this function only.  */
+    temporary_allocation ();
+
+  /* If this fcn was already referenced via a block-scope `extern' decl
+     (or an implicit decl), propagate certain information about the usage.  */
+  if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
+    TREE_ADDRESSABLE (current_function_decl) = 1;
+
+  return 1;
+}
+
+/* Record that this function is going to be a varargs function.
+   This is called before store_parm_decls, which is too early
+   to call mark_varargs directly.  */
+
+void
+c_mark_varargs ()
+{
+  c_function_varargs = 1;
+}
+
+/* Store the parameter declarations into the current function declaration.
+   This is called after parsing the parameter declarations, before
+   digesting the body of the function.
+
+   For an old-style definition, modify the function's type
+   to specify at least the number of arguments.  */
+
+void
+store_parm_decls ()
+{
+  register tree fndecl = current_function_decl;
+  register tree parm;
+
+  /* This is either a chain of PARM_DECLs (if a prototype was used)
+     or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
+  tree specparms = current_function_parms;
+
+  /* This is a list of types declared among parms in a prototype.  */
+  tree parmtags = current_function_parm_tags;
+
+  /* This is a chain of PARM_DECLs from old-style parm declarations.  */
+  register tree parmdecls = getdecls ();
+
+  /* This is a chain of any other decls that came in among the parm
+     declarations.  If a parm is declared with  enum {foo, bar} x;
+     then CONST_DECLs for foo and bar are put here.  */
+  tree nonparms = 0;
+
+  /* Nonzero if this definition is written with a prototype.  */
+  int prototype = 0;
+
+  if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
+    {
+      /* This case is when the function was defined with an ANSI prototype.
+	 The parms already have decls, so we need not do anything here
+	 except record them as in effect
+	 and complain if any redundant old-style parm decls were written.  */
+
+      register tree next;
+      tree others = 0;
+
+      prototype = 1;
+
+      if (parmdecls != 0)
+	{
+	  tree decl, link;
+
+	  error_with_decl (fndecl,
+			   "parm types given both in parmlist and separately");
+	  /* Get rid of the erroneous decls; don't keep them on
+	     the list of parms, since they might not be PARM_DECLs.  */
+	  for (decl = current_binding_level->names;
+	       decl; decl = TREE_CHAIN (decl))
+	    if (DECL_NAME (decl))
+	      IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
+	  for (link = current_binding_level->shadowed;
+	       link; link = TREE_CHAIN (link))
+	    IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
+	  current_binding_level->names = 0;
+	  current_binding_level->shadowed = 0;
+	}
+
+      specparms = nreverse (specparms);
+      for (parm = specparms; parm; parm = next)
+	{
+	  next = TREE_CHAIN (parm);
+	  if (TREE_CODE (parm) == PARM_DECL)
+	    {
+	      if (DECL_NAME (parm) == 0)
+		error_with_decl (parm, "parameter name omitted");
+	      else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
+		{
+		  error_with_decl (parm, "parameter `%s' declared void");
+		  /* Change the type to error_mark_node so this parameter
+		     will be ignored by assign_parms.  */
+		  TREE_TYPE (parm) = error_mark_node;
+		}
+	      pushdecl (parm);
+	    }
+	  else
+	    {
+	      /* If we find an enum constant or a type tag,
+		 put it aside for the moment.  */
+	      TREE_CHAIN (parm) = 0;
+	      others = chainon (others, parm);
+	    }
+	}
+
+      /* Get the decls in their original chain order
+	 and record in the function.  */
+      DECL_ARGUMENTS (fndecl) = getdecls ();
+
+#if 0
+      /* If this function takes a variable number of arguments,
+	 add a phony parameter to the end of the parm list,
+	 to represent the position of the first unnamed argument.  */
+      if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
+	  != void_type_node)
+	{
+	  tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
+	  /* Let's hope the address of the unnamed parm
+	     won't depend on its type.  */
+	  TREE_TYPE (dummy) = integer_type_node;
+	  DECL_ARG_TYPE (dummy) = integer_type_node;
+	  DECL_ARGUMENTS (fndecl)
+	    = chainon (DECL_ARGUMENTS (fndecl), dummy);
+	}
+#endif
+
+      /* Now pushdecl the enum constants.  */
+      for (parm = others; parm; parm = next)
+	{
+	  next = TREE_CHAIN (parm);
+	  if (DECL_NAME (parm) == 0)
+	    ;
+	  else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
+	    ;
+	  else if (TREE_CODE (parm) != PARM_DECL)
+	    pushdecl (parm);
+	}
+
+      storetags (chainon (parmtags, gettags ()));
+    }
+  else
+    {
+      /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
+	 each with a parm name as the TREE_VALUE.
+
+	 PARMDECLS is a chain of declarations for parameters.
+	 Warning! It can also contain CONST_DECLs which are not parameters
+	 but are names of enumerators of any enum types
+	 declared among the parameters.
+
+	 First match each formal parameter name with its declaration.
+	 Associate decls with the names and store the decls
+	 into the TREE_PURPOSE slots.  */
+
+      for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
+	DECL_RESULT (parm) = 0;
+
+      for (parm = specparms; parm; parm = TREE_CHAIN (parm))
+	{
+	  register tree tail, found = NULL;
+
+	  if (TREE_VALUE (parm) == 0)
+	    {
+	      error_with_decl (fndecl, "parameter name missing from parameter list");
+	      TREE_PURPOSE (parm) = 0;
+	      continue;
+	    }
+
+	  /* See if any of the parmdecls specifies this parm by name.
+	     Ignore any enumerator decls.  */
+	  for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
+	    if (DECL_NAME (tail) == TREE_VALUE (parm)
+		&& TREE_CODE (tail) == PARM_DECL)
+	      {
+		found = tail;
+		break;
+	      }
+
+	  /* If declaration already marked, we have a duplicate name.
+	     Complain, and don't use this decl twice.   */
+	  if (found && DECL_RESULT (found) != 0)
+	    {
+	      error_with_decl (found, "multiple parameters named `%s'");
+	      found = 0;
+	    }
+
+	  /* If the declaration says "void", complain and ignore it.  */
+	  if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
+	    {
+	      error_with_decl (found, "parameter `%s' declared void");
+	      TREE_TYPE (found) = integer_type_node;
+	      DECL_ARG_TYPE (found) = integer_type_node;
+	      layout_decl (found, 0);
+	    }
+
+	  /* Traditionally, a parm declared float is actually a double.  */
+	  if (found && flag_traditional
+	      && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
+	    {
+	      TREE_TYPE (found) = double_type_node;
+	      DECL_ARG_TYPE (found) = double_type_node;
+	      layout_decl (found, 0);
+	    }
+
+	  /* If no declaration found, default to int.  */
+	  if (!found)
+	    {
+	      found = build_decl (PARM_DECL, TREE_VALUE (parm),
+				  integer_type_node);
+	      DECL_ARG_TYPE (found) = TREE_TYPE (found);
+	      DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
+	      DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
+	      if (extra_warnings)
+		warning_with_decl (found, "type of `%s' defaults to `int'");
+	      pushdecl (found);
+	    }
+
+	  TREE_PURPOSE (parm) = found;
+
+	  /* Mark this decl as "already found" -- see test, above.
+	     It is safe to use DECL_RESULT for this
+	     since it is not used in PARM_DECLs or CONST_DECLs.  */
+	  DECL_RESULT (found) = error_mark_node;
+	}
+
+      /* Put anything which is on the parmdecls chain and which is
+	 not a PARM_DECL onto the list NONPARMS.  (The types of
+	 non-parm things which might appear on the list include
+	 enumerators and NULL-named TYPE_DECL nodes.) Complain about
+	 any actual PARM_DECLs not matched with any names.  */
+
+      nonparms = 0;
+      for (parm = parmdecls; parm; )
+	{
+	  tree next = TREE_CHAIN (parm);
+	  TREE_CHAIN (parm) = 0;
+
+	  if (TREE_CODE (parm) != PARM_DECL)
+	    nonparms = chainon (nonparms, parm);
+	  else
+	    {
+	      /* Complain about args with incomplete types.  */
+	      if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
+	        {
+	          error_with_decl (parm, "parameter `%s' has incomplete type");
+	          TREE_TYPE (parm) = error_mark_node;
+	        }
+
+	      if (DECL_RESULT (parm) == 0)
+	        {
+	          error_with_decl (parm,
+			           "declaration for parameter `%s' but no such parameter");
+	          /* Pretend the parameter was not missing.
+		     This gets us to a standard state and minimizes
+		     further error messages.  */
+	          specparms
+		    = chainon (specparms,
+			       tree_cons (parm, NULL_TREE, NULL_TREE));
+		}
+	    }
+
+	  parm = next;
+	}
+
+      /* Chain the declarations together in the order of the list of names.  */
+      /* Store that chain in the function decl, replacing the list of names.  */
+      parm = specparms;
+      DECL_ARGUMENTS (fndecl) = 0;
+      {
+	register tree last;
+	for (last = 0; parm; parm = TREE_CHAIN (parm))
+	  if (TREE_PURPOSE (parm))
+	    {
+	      if (last == 0)
+		DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
+	      else
+		TREE_CHAIN (last) = TREE_PURPOSE (parm);
+	      last = TREE_PURPOSE (parm);
+	      TREE_CHAIN (last) = 0;
+	    }
+      }
+
+      /* If there was a previous prototype,
+	 set the DECL_ARG_TYPE of each argument according to
+	 the type previously specified, and report any mismatches.  */
+
+      if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
+	{
+	  register tree type;
+	  for (parm = DECL_ARGUMENTS (fndecl),
+	       type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
+	       parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
+				 != void_type_node));
+	       parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
+	    {
+	      if (parm == 0 || type == 0
+		  || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
+		{
+		  error ("number of arguments doesn't match prototype");
+		  error_with_file_and_line (current_function_prototype_file,
+					    current_function_prototype_line,
+					    "prototype declaration");
+		  break;
+		}
+	      /* Type for passing arg must be consistent
+		 with that declared for the arg.  */
+	      if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
+		{
+		  if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
+		      == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
+		    {
+		      /* Adjust argument to match prototype.  E.g. a previous
+			 `int foo(float);' prototype causes
+			 `int foo(x) float x; {...}' to be treated like
+			 `int foo(float x) {...}'.  This is particularly
+			 useful for argument types like uid_t.  */
+		      DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
+#ifdef PROMOTE_PROTOTYPES
+		      if (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
+			  && TYPE_PRECISION (TREE_TYPE (parm))
+			  < TYPE_PRECISION (integer_type_node))
+			DECL_ARG_TYPE (parm) = integer_type_node;
+#endif
+		      if (pedantic)
+			{
+			  pedwarn ("promoted argument `%s' doesn't match prototype",
+				   IDENTIFIER_POINTER (DECL_NAME (parm)));
+			  warning_with_file_and_line
+			    (current_function_prototype_file,
+			     current_function_prototype_line,
+			     "prototype declaration");
+			}
+		    }
+		  /* If -traditional, allow `int' argument to match
+		     `unsigned' prototype.  */
+		  else if (! (flag_traditional
+			      && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
+			      && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
+		    {
+		      error ("argument `%s' doesn't match prototype",
+			     IDENTIFIER_POINTER (DECL_NAME (parm)));
+		      error_with_file_and_line (current_function_prototype_file,
+						current_function_prototype_line,
+						"prototype declaration");
+		    }
+		}
+	    }
+	  TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
+	}
+
+      /* Otherwise, create a prototype that would match.  */
+
+      else
+	{
+	  register tree actual, type;
+	  register tree last = 0;
+
+	  for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
+	    {
+	      type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
+				     NULL_TREE);
+	      if (last)
+		TREE_CHAIN (last) = type;
+	      else
+		actual = type;
+	      last = type;
+	    }
+	  type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
+	  if (last)
+	    TREE_CHAIN (last) = type;
+	  else
+	    actual = type;
+
+	  /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
+	     of the type of this function, but we need to avoid having this
+	     affect the types of other similarly-typed functions, so we must
+	     first force the generation of an identical (but separate) type
+	     node for the relevant function type.  The new node we create
+	     will be a variant of the main variant of the original function
+	     type.  */
+
+	  TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
+
+	  TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
+	}
+
+      /* Now store the final chain of decls for the arguments
+	 as the decl-chain of the current lexical scope.
+	 Put the enumerators in as well, at the front so that
+	 DECL_ARGUMENTS is not modified.  */
+
+      storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
+    }
+
+  /* Make sure the binding level for the top of the function body
+     gets a BLOCK if there are any in the function.
+     Otherwise, the dbx output is wrong.  */
+
+  keep_next_if_subblocks = 1;
+
+  /* ??? This might be an improvement,
+     but needs to be thought about some more.  */
+#if 0
+  keep_next_level_flag = 1;
+#endif
+
+  /* Write a record describing this function definition to the prototypes
+     file (if requested).  */
+
+  gen_aux_info_record (fndecl, 1, 0, prototype);
+
+  /* Initialize the RTL code for the function.  */
+
+  init_function_start (fndecl, input_filename, lineno);
+
+  /* If this is a varargs function, inform function.c.  */
+
+  if (c_function_varargs)
+    mark_varargs ();
+
+  /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
+
+  declare_function_name ();
+
+  /* Set up parameters and prepare for return, for the function.  */
+
+  expand_function_start (fndecl, 0);
+
+  /* If this function is `main', emit a call to `__main'
+     to run global initializers, etc.  */
+  if (DECL_NAME (fndecl)
+      && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
+      && DECL_CONTEXT (fndecl) == NULL_TREE)
+    expand_main_function ();
+}
+
+/* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
+   each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
+   stands for an ellipsis in the identifier list.
+
+   PARMLIST is the data returned by get_parm_info for the
+   parmlist that follows the semicolon.
+
+   We return a value of the same sort that get_parm_info returns,
+   except that it describes the combination of identifiers and parmlist.  */
+
+tree
+combine_parm_decls (specparms, parmlist, void_at_end)
+     tree specparms, parmlist;
+     int void_at_end;
+{
+  register tree fndecl = current_function_decl;
+  register tree parm;
+
+  tree parmdecls = TREE_PURPOSE (parmlist);
+
+  /* This is a chain of any other decls that came in among the parm
+     declarations.  They were separated already by get_parm_info,
+     so we just need to keep them separate.  */
+  tree nonparms = TREE_VALUE (parmlist);
+
+  tree types = 0;
+
+  for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
+    DECL_RESULT (parm) = 0;
+
+  for (parm = specparms; parm; parm = TREE_CHAIN (parm))
+    {
+      register tree tail, found = NULL;
+
+      /* See if any of the parmdecls specifies this parm by name.  */
+      for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
+	if (DECL_NAME (tail) == TREE_VALUE (parm))
+	  {
+	    found = tail;
+	    break;
+	  }
+
+      /* If declaration already marked, we have a duplicate name.
+	 Complain, and don't use this decl twice.   */
+      if (found && DECL_RESULT (found) != 0)
+	{
+	  error_with_decl (found, "multiple parameters named `%s'");
+	  found = 0;
+	}
+
+      /* If the declaration says "void", complain and ignore it.  */
+      if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
+	{
+	  error_with_decl (found, "parameter `%s' declared void");
+	  TREE_TYPE (found) = integer_type_node;
+	  DECL_ARG_TYPE (found) = integer_type_node;
+	  layout_decl (found, 0);
+	}
+
+      /* Traditionally, a parm declared float is actually a double.  */
+      if (found && flag_traditional
+	  && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
+	{
+	  TREE_TYPE (found) = double_type_node;
+	  DECL_ARG_TYPE (found) = double_type_node;
+	  layout_decl (found, 0);
+	}
+
+      /* If no declaration found, default to int.  */
+      if (!found)
+	{
+	  found = build_decl (PARM_DECL, TREE_VALUE (parm),
+			      integer_type_node);
+	  DECL_ARG_TYPE (found) = TREE_TYPE (found);
+	  DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
+	  DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
+	  error_with_decl (found, "type of parameter `%s' is not declared");
+	  pushdecl (found);
+	}
+
+      TREE_PURPOSE (parm) = found;
+
+      /* Mark this decl as "already found" -- see test, above.
+	 It is safe to use DECL_RESULT for this
+	 since it is not used in PARM_DECLs or CONST_DECLs.  */
+      DECL_RESULT (found) = error_mark_node;
+    }
+
+  /* Complain about any actual PARM_DECLs not matched with any names.  */
+
+  for (parm = parmdecls; parm; )
+    {
+      tree next = TREE_CHAIN (parm);
+      TREE_CHAIN (parm) = 0;
+
+      /* Complain about args with incomplete types.  */
+      if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
+	{
+	  error_with_decl (parm, "parameter `%s' has incomplete type");
+	  TREE_TYPE (parm) = error_mark_node;
+	}
+
+      if (DECL_RESULT (parm) == 0)
+	{
+	  error_with_decl (parm,
+			   "declaration for parameter `%s' but no such parameter");
+	  /* Pretend the parameter was not missing.
+	     This gets us to a standard state and minimizes
+	     further error messages.  */
+	  specparms
+	    = chainon (specparms,
+		       tree_cons (parm, NULL_TREE, NULL_TREE));
+	}
+
+      parm = next;
+    }
+
+  /* Chain the declarations together in the order of the list of names.
+     At the same time, build up a list of their types, in reverse order.  */
+
+  parm = specparms;
+  parmdecls = 0;
+  {
+    register tree last;
+    for (last = 0; parm; parm = TREE_CHAIN (parm))
+      if (TREE_PURPOSE (parm))
+	{
+	  if (last == 0)
+	    parmdecls = TREE_PURPOSE (parm);
+	  else
+	    TREE_CHAIN (last) = TREE_PURPOSE (parm);
+	  last = TREE_PURPOSE (parm);
+	  TREE_CHAIN (last) = 0;
+
+	  types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
+	}
+  }
+  
+  if (void_at_end)
+    return saveable_tree_cons (parmdecls, nonparms,
+			       nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
+
+  return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
+}
+
+/* Finish up a function declaration and compile that function
+   all the way to assembler language output.  The free the storage
+   for the function definition.
+
+   This is called after parsing the body of the function definition.
+
+   NESTED is nonzero if the function being finished is nested in another.  */
+
+void
+finish_function (nested)
+     int nested;
+{
+  register tree fndecl = current_function_decl;
+
+/*  TREE_READONLY (fndecl) = 1;
+    This caused &foo to be of type ptr-to-const-function
+    which then got a warning when stored in a ptr-to-function variable.  */
+
+  poplevel (1, 0, 1);
+  BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
+
+  /* Must mark the RESULT_DECL as being in this function.  */
+
+  DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
+
+  /* Obey `register' declarations if `setjmp' is called in this fn.  */
+  if (flag_traditional && current_function_calls_setjmp)
+    {
+      setjmp_protect (DECL_INITIAL (fndecl));
+      setjmp_protect_args ();
+    }
+
+#ifdef DEFAULT_MAIN_RETURN
+  if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
+    {
+      if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
+	  != integer_type_node)
+	warning_with_decl (fndecl, "return type of `%s' is not `int'");
+      else
+	{
+	  /* Make it so that `main' always returns success by default.  */
+	  DEFAULT_MAIN_RETURN;
+	}
+    }
+#endif
+
+  /* Generate rtl for function exit.  */
+  expand_function_end (input_filename, lineno);
+
+  /* So we can tell if jump_optimize sets it to 1.  */
+  can_reach_end = 0;
+
+  /* Run the optimizers and output the assembler code for this function.  */
+  rest_of_compilation (fndecl);
+
+  current_function_returns_null |= can_reach_end;
+
+  if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
+    warning ("`volatile' function does return");
+  else if (warn_return_type && can_reach_end
+	   && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
+    /* If this function returns non-void and control can drop through,
+       complain.  */
+    warning ("control reaches end of non-void function");
+  /* With just -W, complain only if function returns both with
+     and without a value.  */
+  else if (extra_warnings
+	   && current_function_returns_value && current_function_returns_null)
+    warning ("this function may return with or without a value");
+
+  /* Free all the tree nodes making up this function.  */
+  /* Switch back to allocating nodes permanently
+     until we start another function.  */
+  if (! nested)
+    permanent_allocation ();
+
+  if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
+    {
+      /* Stop pointing to the local nodes about to be freed.  */
+      /* But DECL_INITIAL must remain nonzero so we know this
+	 was an actual function definition.  */
+      /* For a nested function, this is done in pop_c_function_context.  */
+      DECL_INITIAL (fndecl) = error_mark_node;
+      DECL_ARGUMENTS (fndecl) = 0;
+    }
+
+  if (! nested)
+    {
+      /* Let the error reporting routines know that we're outside a
+	 function.  For a nested function, this value is used in
+	 pop_c_function_context and then reset via pop_function_context.  */
+      current_function_decl = NULL;
+    }
+}
+
+/* Save and restore the variables in this file and elsewhere
+   that keep track of the progress of compilation of the current function.
+   Used for nested functions.  */
+
+struct c_function
+{
+  struct c_function *next;
+  tree enum_next_value;
+  tree named_labels;
+  tree shadowed_labels;
+  int returns_value;
+  int returns_null;
+  int warn_about_return_type;
+  int extern_inline;
+  struct binding_level *binding_level;
+};
+
+struct c_function *c_function_chain;
+
+/* Save and reinitialize the variables
+   used during compilation of a C function.  */
+
+void
+push_c_function_context ()
+{
+  struct c_function *p
+    = (struct c_function *) xmalloc (sizeof (struct c_function));
+
+  if (pedantic)
+    pedwarn ("ANSI C forbids nested functions");
+
+  push_function_context ();
+
+  p->next = c_function_chain;
+  c_function_chain = p;
+
+  p->enum_next_value = enum_next_value;
+  p->named_labels = named_labels;
+  p->shadowed_labels = shadowed_labels;
+  p->returns_value = current_function_returns_value;
+  p->returns_null = current_function_returns_null;
+  p->warn_about_return_type = warn_about_return_type;
+  p->extern_inline = current_extern_inline;
+  p->binding_level = current_binding_level;
+}
+
+/* Restore the variables used during compilation of a C function.  */
+
+void
+pop_c_function_context ()
+{
+  struct c_function *p = c_function_chain;
+  tree link;
+
+  /* Bring back all the labels that were shadowed.  */
+  for (link = shadowed_labels; link; link = TREE_CHAIN (link))
+    if (DECL_NAME (TREE_VALUE (link)) != 0)
+      IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
+	= TREE_VALUE (link);
+
+  if (DECL_SAVED_INSNS (current_function_decl) == 0)
+    {
+      /* Stop pointing to the local nodes about to be freed.  */
+      /* But DECL_INITIAL must remain nonzero so we know this
+	 was an actual function definition.  */
+      DECL_INITIAL (current_function_decl) = error_mark_node;
+      DECL_ARGUMENTS (current_function_decl) = 0;
+    }
+
+  pop_function_context ();
+
+  c_function_chain = p->next;
+
+  enum_next_value = p->enum_next_value;
+  named_labels = p->named_labels;
+  shadowed_labels = p->shadowed_labels;
+  current_function_returns_value = p->returns_value;
+  current_function_returns_null = p->returns_null;
+  warn_about_return_type = p->warn_about_return_type;
+  current_extern_inline = p->extern_inline;
+  current_binding_level = p->binding_level;
+
+  free (p);
+}
diff --git a/gnu/usr.bin/cc/cc1/c-iterate.c b/gnu/usr.bin/cc/cc1/c-iterate.c
new file mode 100644
index 000000000000..09df3e466336
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-iterate.c
@@ -0,0 +1,594 @@
+/* Build expressions with type checking for C compiler.
+   Copyright (C) 1987, 1988, 1989, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* This file is part of the C front end.
+   It is responsible for implementing iterators,
+   both their declarations and the expansion of statements using them.  */
+
+#include "config.h"
+#include <stdio.h>
+#include "tree.h"
+#include "c-tree.h"
+#include "flags.h"
+#include "obstack.h"
+#include "rtl.h"
+
+static void expand_stmt_with_iterators_1 ();
+static tree collect_iterators ();
+static void iterator_loop_prologue ();
+static void iterator_loop_epilogue ();
+static void add_ixpansion ();
+static void delete_ixpansion();
+static int top_level_ixpansion_p ();
+static void istack_sublevel_to_current ();
+
+/* A special obstack, and a pointer to the start of
+   all the data in it (so we can free everything easily).  */
+static struct obstack ixp_obstack;
+static char *ixp_firstobj;
+
+/*
+		KEEPING TRACK OF EXPANSIONS
+
+   In order to clean out expansions corresponding to statements inside
+   "{(...)}" constructs we have to keep track of all expansions.  The
+   cleanup is needed when an automatic, or implicit, expansion on
+   iterator, say X, happens to a statement which contains a {(...)}
+   form with a statement already expanded on X.  In this case we have
+   to go back and cleanup the inner expansion.  This can be further
+   complicated by the fact that {(...)} can be nested.
+
+   To make this cleanup possible, we keep lists of all expansions, and
+   to make it work for nested constructs, we keep a stack.  The list at
+   the top of the stack (ITER_STACK.CURRENT_LEVEL) corresponds to the
+   currently parsed level.  All expansions of the levels below the
+   current one are kept in one list whose head is pointed to by
+   ITER_STACK.SUBLEVEL_FIRST (SUBLEVEL_LAST is there for making merges
+   easy).  The process works as follows:
+
+   -- On "({"  a new node is added to the stack by PUSH_ITERATOR_STACK.
+	       The sublevel list is not changed at this point.
+
+   -- On "})" the list for the current level is appended to the sublevel
+	      list. 
+
+   -- On ";"  sublevel lists are appended to the current level lists.
+	      The reason is this: if they have not been superseded by the
+	      expansion at the current level, they still might be
+	      superseded later by the expansion on the higher level.
+	      The levels do not have to distinguish levels below, so we
+	      can merge the lists together.  */
+
+struct  ixpansion
+{
+  tree ixdecl;			/* Iterator decl */
+  rtx  ixprologue_start;	/* First insn of epilogue. NULL means */
+  /* explicit (FOR) expansion*/
+  rtx  ixprologue_end;
+  rtx  ixepilogue_start;
+  rtx  ixepilogue_end;
+  struct ixpansion *next;	/* Next in the list */
+};
+
+struct iter_stack_node
+{
+  struct ixpansion *first;	/* Head of list of ixpansions */
+  struct ixpansion *last;	/* Last node in list  of ixpansions */
+  struct iter_stack_node *next; /* Next level iterator stack node  */
+};
+
+struct iter_stack_node *iter_stack;
+
+struct iter_stack_node sublevel_ixpansions;
+
+/* During collect_iterators, a list of SAVE_EXPRs already scanned.  */
+static tree save_exprs;
+
+/* Initialize our obstack once per compilation.  */
+
+void
+init_iterators ()
+{
+  gcc_obstack_init (&ixp_obstack);
+  ixp_firstobj = (char *) obstack_alloc (&ixp_obstack, 0);
+}
+
+/* Handle the start of an explicit `for' loop for iterator IDECL.  */
+
+void
+iterator_for_loop_start (idecl)
+     tree idecl;
+{
+  ITERATOR_BOUND_P (idecl) = 1;
+  add_ixpansion (idecl, 0, 0, 0, 0);
+  iterator_loop_prologue (idecl, 0, 0);
+}
+
+/* Handle the end of an explicit `for' loop for iterator IDECL.  */
+
+void
+iterator_for_loop_end (idecl)
+     tree idecl;
+{
+  iterator_loop_epilogue (idecl, 0, 0);
+  ITERATOR_BOUND_P (idecl) = 0;
+}
+
+/*
+  		ITERATOR RTL EXPANSIONS
+
+   Expanding simple statements with iterators is straightforward:
+   collect the list of all free iterators in the statement, and
+   generate a loop for each of them.
+
+   An iterator is "free" if it has not been "bound" by a FOR
+   operator.  The DECL_RTL of the iterator is the loop counter.  */
+
+/* Expand a statement STMT, possibly containing iterator usage, into RTL.  */
+
+void
+iterator_expand (stmt)
+    tree stmt;
+{
+  tree iter_list;
+  save_exprs = NULL_TREE;
+  iter_list = collect_iterators (stmt, NULL_TREE);
+  expand_stmt_with_iterators_1 (stmt, iter_list);
+  istack_sublevel_to_current ();
+}
+
+
+static void 
+expand_stmt_with_iterators_1 (stmt, iter_list)
+     tree stmt, iter_list;
+{
+  if (iter_list == 0)
+    expand_expr_stmt (stmt);
+  else
+    {
+      tree current_iterator = TREE_VALUE (iter_list);
+      tree iter_list_tail   = TREE_CHAIN (iter_list);
+      rtx p_start, p_end, e_start, e_end;
+
+      iterator_loop_prologue (current_iterator, &p_start, &p_end);
+      expand_stmt_with_iterators_1 (stmt, iter_list_tail);
+      iterator_loop_epilogue (current_iterator, &e_start, &e_end);
+
+      /** Delete all inner expansions based on current_iterator **/
+      /** before adding the outer one. **/
+
+      delete_ixpansion (current_iterator);
+      add_ixpansion (current_iterator, p_start, p_end, e_start, e_end);
+    }
+}
+
+
+/* Return a list containing all the free (i.e. not bound by a
+   containing `for' statement) iterators mentioned in EXP, plus those
+   in LIST.  Do not add duplicate entries to the list.  */
+
+static tree
+collect_iterators (exp, list)
+     tree exp, list;
+{
+  if (exp == 0) return list;
+
+  switch (TREE_CODE (exp))
+    {
+    case VAR_DECL:
+      if (! ITERATOR_P (exp) || ITERATOR_BOUND_P (exp))
+	return list;
+      if (value_member (exp, list))
+	return list;
+      return tree_cons (NULL_TREE, exp, list);
+
+    case TREE_LIST:
+      {
+	tree tail;
+	for (tail = exp; tail; tail = TREE_CHAIN (tail))
+	  list = collect_iterators (TREE_VALUE (tail), list);
+	return list;
+      }
+
+    case SAVE_EXPR:
+      /* In each scan, scan a given save_expr only once.  */
+      {
+	tree tail;
+	for (tail = save_exprs; tail; tail = TREE_CHAIN (tail))
+	  if (TREE_VALUE (tail) == exp)
+	    return list;
+      }
+      save_exprs = tree_cons (NULL_TREE, exp, save_exprs);
+      return collect_iterators (TREE_OPERAND (exp, 0), list);
+
+      /* we do not automatically iterate blocks -- one must */
+      /* use the FOR construct to do that */
+
+    case BLOCK:
+      return list;
+
+    default:
+      switch (TREE_CODE_CLASS (TREE_CODE (exp)))
+	{
+	case '1':
+	  return collect_iterators (TREE_OPERAND (exp, 0), list);
+
+	case '2':
+	case '<':
+	  return collect_iterators (TREE_OPERAND (exp, 0),
+				    collect_iterators (TREE_OPERAND (exp, 1),
+						       list));
+
+	case 'e':
+	case 'r':
+	  {
+	    int num_args = tree_code_length[(int) TREE_CODE (exp)];
+	    int i;
+
+	    /* Some tree codes have RTL, not trees, as operands.  */
+	    switch (TREE_CODE (exp))
+	      {
+	      case CALL_EXPR:
+		num_args = 2;
+		break;
+	      case METHOD_CALL_EXPR:
+		num_args = 3;
+		break;
+	      case WITH_CLEANUP_EXPR:
+		num_args = 1;
+		break;
+	      case RTL_EXPR:
+		return list;
+	      }
+		
+	    for (i = 0; i < num_args; i++)
+	      list = collect_iterators (TREE_OPERAND (exp, i), list);
+	    return list;
+	  }
+	default:
+	  return list;
+	}
+    }
+}
+
+/* Emit rtl for the start of a loop for iterator IDECL.
+
+   If necessary, create loop counter rtx and store it as DECL_RTL of IDECL.
+
+   The prologue normally starts and ends with notes, which are returned
+   by this function in *START_NOTE and *END_NODE.
+   If START_NOTE and END_NODE are 0, we don't make those notes.  */
+
+static void
+iterator_loop_prologue (idecl, start_note, end_note)
+     tree idecl;
+     rtx *start_note, *end_note;
+{
+  /* Force the save_expr in DECL_INITIAL to be calculated
+     if it hasn't been calculated yet.  */
+  expand_expr (DECL_INITIAL (idecl), 0, VOIDmode, 0);
+
+  if (DECL_RTL (idecl) == 0)
+    expand_decl (idecl);
+
+  if (start_note)
+    *start_note = emit_note (0, NOTE_INSN_DELETED);
+  /* Initialize counter.  */
+  expand_expr (build (MODIFY_EXPR, TREE_TYPE (idecl),
+		      idecl, integer_zero_node),
+	       0, VOIDmode, 0);
+
+  expand_start_loop_continue_elsewhere (1);
+
+  ITERATOR_BOUND_P (idecl) = 1;
+
+  if (end_note)
+    *end_note = emit_note (0, NOTE_INSN_DELETED);
+}
+
+/* Similar to the previous function, but for the end of the loop.
+
+   DECL_RTL is zeroed unless we are inside "({...})". The reason for that is
+   described below.
+
+   When we create two (or more) loops based on the same IDECL, and
+   both inside the same "({...})"  construct, we must be prepared to
+   delete both of the loops and create a single one on the level
+   above, i.e.  enclosing the "({...})". The new loop has to use the
+   same counter rtl because the references to the iterator decl
+   (IDECL) have already been expanded as references to the counter
+   rtl.
+
+   It is incorrect to use the same counter reg in different functions,
+   and it is desirable to use different counters in disjoint loops
+   when we know there's no need to combine them (because then they can
+   get allocated separately).  */
+
+static void
+iterator_loop_epilogue (idecl, start_note, end_note)
+     tree idecl;
+     rtx *start_note, *end_note;
+{
+  tree test, incr;
+
+  if (start_note)
+    *start_note = emit_note (0, NOTE_INSN_DELETED);
+  expand_loop_continue_here ();
+  incr = build_binary_op (PLUS_EXPR, idecl, integer_one_node, 0);
+  expand_expr (build (MODIFY_EXPR, TREE_TYPE (idecl), idecl, incr),
+	       0, VOIDmode, 0);
+  test = build_binary_op (LT_EXPR, idecl, DECL_INITIAL (idecl), 0);
+  expand_exit_loop_if_false (0, test);
+  expand_end_loop ();
+
+  ITERATOR_BOUND_P (idecl) = 0;
+  /* we can reset rtl since there is not chance that this expansion */
+  /* would be superceded by a higher level one */
+  if (top_level_ixpansion_p ())
+    DECL_RTL (idecl) = 0;
+  if (end_note)
+    *end_note = emit_note (0, NOTE_INSN_DELETED);
+}
+
+/* Return true if we are not currently inside a "({...})" construct.  */
+
+static int
+top_level_ixpansion_p ()
+{
+  return iter_stack == 0;
+}
+
+/* Given two chains of iter_stack_nodes,
+   append the nodes in X into Y.  */
+
+static void
+isn_append (x, y)
+     struct iter_stack_node *x, *y;
+{
+  if (x->first == 0) 
+    return;
+
+  if (y->first == 0)
+    {
+      y->first = x->first;
+      y->last  = x->last;
+    }
+  else
+    {
+      y->last->next = x->first;
+      y->last = x->last;
+    }
+}
+
+/** Make X empty **/
+
+#define ISN_ZERO(X) (X).first=(X).last=0
+
+/* Move the ixpansions in sublevel_ixpansions into the current
+   node on the iter_stack, or discard them if the iter_stack is empty.
+   We do this at the end of a statement.  */
+
+static void
+istack_sublevel_to_current ()
+{
+  /* At the top level we can throw away sublevel's expansions  **/
+  /* because there is nobody above us to ask for a cleanup **/
+  if (iter_stack != 0)
+    /** Merging with empty sublevel list is a no-op **/
+    if (sublevel_ixpansions.last)
+      isn_append (&sublevel_ixpansions, iter_stack);
+
+  if (iter_stack == 0)
+    obstack_free (&ixp_obstack, ixp_firstobj);
+
+  ISN_ZERO (sublevel_ixpansions);
+}
+
+/* Push a new node on the iter_stack, when we enter a ({...}).  */
+
+void
+push_iterator_stack ()
+{
+  struct iter_stack_node *new_top
+    = (struct iter_stack_node*) 
+      obstack_alloc (&ixp_obstack, sizeof (struct iter_stack_node));
+
+  new_top->first = 0;
+  new_top->last = 0;
+  new_top->next = iter_stack;
+  iter_stack = new_top;
+}
+
+/* Pop iter_stack, moving the ixpansions in the node being popped
+   into sublevel_ixpansions.  */
+
+void
+pop_iterator_stack ()
+{
+  if (iter_stack == 0)
+    abort ();
+
+  isn_append (iter_stack, &sublevel_ixpansions);
+  /** Pop current level node: */
+  iter_stack = iter_stack->next;
+}
+
+
+/* Record an iterator expansion ("ixpansion") for IDECL.
+   The remaining paramters are the notes in the loop entry
+   and exit rtl.  */
+
+static void
+add_ixpansion (idecl, pro_start, pro_end, epi_start, epi_end)
+     tree idecl;
+     rtx pro_start, pro_end, epi_start, epi_end;
+{
+  struct ixpansion* newix;
+    
+  /* Do nothing if we are not inside "({...})",
+     as in that case this expansion can't need subsequent RTL modification.  */
+  if (iter_stack == 0)
+    return;
+
+  newix = (struct ixpansion*) obstack_alloc (&ixp_obstack,
+					     sizeof (struct ixpansion));
+  newix->ixdecl = idecl;
+  newix->ixprologue_start = pro_start;
+  newix->ixprologue_end   = pro_end;
+  newix->ixepilogue_start = epi_start;
+  newix->ixepilogue_end   = epi_end;
+
+  newix->next = iter_stack->first;
+  iter_stack->first = newix;
+  if (iter_stack->last == 0)
+    iter_stack->last = newix;
+}
+
+/* Delete the RTL for all ixpansions for iterator IDECL
+   in our sublevels.  We do this when we make a larger
+   containing expansion for IDECL.  */
+
+static void
+delete_ixpansion (idecl)
+     tree idecl;
+{
+  struct ixpansion* previx = 0, *ix;
+
+  for (ix = sublevel_ixpansions.first; ix; ix = ix->next)
+    if (ix->ixdecl == idecl)
+      {
+	/** zero means that this is a mark for FOR -- **/
+	/** we do not delete anything, just issue an error. **/
+
+	if (ix->ixprologue_start == 0)
+	  error_with_decl (idecl,
+			   "`for (%s)' appears within implicit iteration");
+	else
+	  {
+	    rtx insn;
+	    /* We delete all insns, including notes because leaving loop */
+	    /* notes and barriers produced by iterator expansion would */
+	    /* be misleading to other phases */
+
+	    for (insn = NEXT_INSN (ix->ixprologue_start);
+		 insn != ix->ixprologue_end;
+		 insn = NEXT_INSN (insn)) 
+	      delete_insn (insn);
+	    for (insn = NEXT_INSN (ix->ixepilogue_start);
+		 insn != ix->ixepilogue_end;
+		 insn = NEXT_INSN (insn)) 
+	      delete_insn (insn);
+	  }
+
+	/* Delete this ixpansion from sublevel_ixpansions.  */
+	if (previx)
+	  previx->next = ix->next;
+	else 
+	  sublevel_ixpansions.first = ix->next;
+	if (sublevel_ixpansions.last == ix)
+	  sublevel_ixpansions.last = previx;
+      }
+    else
+      previx = ix;
+}
+
+#ifdef DEBUG_ITERATORS
+
+/* The functions below are for use from source level debugger.
+   They print short forms of iterator lists and the iterator stack.  */
+
+/* Print the name of the iterator D.  */
+
+void
+prdecl (d)
+     tree d;
+{
+  if (d)
+    {
+      if (TREE_CODE (d) == VAR_DECL)
+	{
+	  tree tname = DECL_NAME (d);
+	  char *dname = IDENTIFIER_POINTER (tname);
+	  fprintf (stderr, dname);
+	}
+      else
+	fprintf (stderr, "<<Not a Decl!!!>>");
+    }
+  else
+    fprintf (stderr, "<<NULL!!>>");
+}
+
+/* Print Iterator List -- names only */
+
+tree
+pil (head)
+     tree head;
+{
+  tree current, next;
+  for (current = head; current; current = next)
+    {
+      tree node = TREE_VALUE (current);
+      prdecl (node);
+      next = TREE_CHAIN (current);
+      if (next) fprintf (stderr, ",");
+    }
+  fprintf (stderr, "\n");
+}
+
+/* Print IXpansion List */
+
+struct ixpansion *
+pixl (head)
+     struct ixpansion *head;
+{
+  struct ixpansion *current, *next;
+  fprintf (stderr, "> ");
+  if (head == 0)
+    fprintf (stderr, "(empty)");
+	
+  for (current=head; current; current = next)
+    {
+      tree node = current->ixdecl;
+      prdecl (node);
+      next = current->next;
+      if (next)
+	fprintf (stderr, ",");
+    }
+  fprintf (stderr, "\n");
+  return head;
+}
+
+/* Print Iterator Stack*/
+
+void
+pis ()
+{
+  struct iter_stack_node *stack_node;
+
+  fprintf (stderr, "--SubLevel: ");
+  pixl (sublevel_ixpansions.first);
+  fprintf (stderr, "--Stack:--\n");
+  for (stack_node = iter_stack;
+       stack_node;
+       stack_node = stack_node->next)
+    pixl (stack_node->first);
+}
+
+#endif /* DEBUG_ITERATORS */
diff --git a/gnu/usr.bin/cc/cc1/c-lang.c b/gnu/usr.bin/cc/cc1/c-lang.c
new file mode 100644
index 000000000000..8b46b3c10cb5
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-lang.c
@@ -0,0 +1,129 @@
+/* Language-specific hook definitions for C front end.
+   Copyright (C) 1991 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include "config.h"
+#include "tree.h"
+#include <stdio.h>
+#include "input.h"
+
+/* Each of the functions defined here
+   is an alternative to a function in objc-actions.c.  */
+   
+int
+lang_decode_option (p)
+     char *p;
+{
+  return c_decode_option (p);
+}
+
+void
+lang_init ()
+{
+  /* the beginning of the file is a new line; check for # */
+  /* With luck, we discover the real source file's name from that
+     and put it in input_filename.  */
+  ungetc (check_newline (), finput);
+}
+
+void
+lang_finish ()
+{
+}
+
+char *
+lang_identify ()
+{
+  return "c";
+}
+
+void
+print_lang_statistics ()
+{
+}
+
+/* Used by c-lex.c, but only for objc.  */
+
+tree
+lookup_interface (arg)
+     tree arg;
+{
+  return 0;
+}
+
+tree
+is_class_name (arg)
+    tree arg;
+{
+  return 0;
+}
+
+void
+maybe_objc_check_decl (decl)
+     tree decl;
+{
+}
+
+int
+maybe_objc_comptypes (lhs, rhs, reflexive)
+     tree lhs, rhs;
+     int reflexive;
+{
+  return -1;
+}
+
+tree
+maybe_objc_method_name (decl)
+    tree decl;
+{
+  return 0;
+}
+
+tree
+maybe_building_objc_message_expr ()
+{
+  return 0;
+}
+
+int
+recognize_objc_keyword ()
+{
+  return 0;
+}
+
+tree
+build_objc_string (len, str)
+    int len;
+    char *str;
+{
+  abort ();
+  return NULL_TREE;
+}
+
+void
+GNU_xref_begin ()
+{
+  fatal ("GCC does not yet support XREF");
+}
+
+void
+GNU_xref_end ()
+{
+  fatal ("GCC does not yet support XREF");
+}
diff --git a/gnu/usr.bin/cc/cc1/c-lex.c b/gnu/usr.bin/cc/cc1/c-lex.c
new file mode 100644
index 000000000000..d83b5dccb623
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-lex.c
@@ -0,0 +1,2111 @@
+/* Lexical analyzer for C and Objective C.
+   Copyright (C) 1987, 1988, 1989, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#include <stdio.h>
+#include <errno.h>
+#include <setjmp.h>
+
+#include "config.h"
+#include "rtl.h"
+#include "tree.h"
+#include "input.h"
+#include "c-lex.h"
+#include "c-tree.h"
+#include "flags.h"
+#include "c-parse.h"
+
+#ifdef MULTIBYTE_CHARS
+#include <stdlib.h>
+#include <locale.h>
+#endif
+
+#ifndef errno
+extern int errno;
+#endif
+
+/* The elements of `ridpointers' are identifier nodes
+   for the reserved type names and storage classes.
+   It is indexed by a RID_... value.  */
+tree ridpointers[(int) RID_MAX];
+
+/* Cause the `yydebug' variable to be defined.  */
+#define YYDEBUG 1
+
+/* the declaration found for the last IDENTIFIER token read in.
+   yylex must look this up to detect typedefs, which get token type TYPENAME,
+   so it is left around in case the identifier is not a typedef but is
+   used in a context which makes it a reference to a variable.  */
+tree lastiddecl;
+
+/* Nonzero enables objc features.  */
+
+int doing_objc_thang;
+
+extern tree is_class_name ();
+
+extern int yydebug;
+
+/* File used for outputting assembler code.  */
+extern FILE *asm_out_file;
+
+#ifndef WCHAR_TYPE_SIZE
+#ifdef INT_TYPE_SIZE
+#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
+#else
+#define WCHAR_TYPE_SIZE	BITS_PER_WORD
+#endif
+#endif
+
+/* Number of bytes in a wide character.  */
+#define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
+
+static int maxtoken;		/* Current nominal length of token buffer.  */
+char *token_buffer;	/* Pointer to token buffer.
+			   Actual allocated length is maxtoken + 2.
+			   This is not static because objc-parse.y uses it.  */
+
+/* Nonzero if end-of-file has been seen on input.  */
+static int end_of_file;
+
+/* Buffered-back input character; faster than using ungetc.  */
+static int nextchar = -1;
+
+int check_newline ();
+
+/* Nonzero tells yylex to ignore \ in string constants.  */
+static int ignore_escape_flag = 0;
+
+/* C code produced by gperf version 2.5 (GNU C++ version) */
+/* Command-line: gperf -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ c-parse.gperf  */
+struct resword { char *name; short token; enum rid rid; };
+
+#define TOTAL_KEYWORDS 79
+#define MIN_WORD_LENGTH 2
+#define MAX_WORD_LENGTH 20
+#define MIN_HASH_VALUE 10
+#define MAX_HASH_VALUE 144
+/* maximum key range = 135, duplicates = 0 */
+
+#ifdef __GNUC__
+__inline
+#endif
+static unsigned int
+hash (str, len)
+     register char *str;
+     register int unsigned len;
+{
+  static unsigned char asso_values[] =
+    {
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145,  25, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145,   1, 145,  46,   8,  15,
+      61,   6,  36,  48,   3,   5, 145,  18,  63,  25,
+      29,  76,   1, 145,  13,   2,   1,  51,  37,   9,
+       9,   1,   3, 145, 145, 145, 145, 145,
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+      case 3:
+        hval += asso_values[str[2]];
+      case 2:
+      case 1:
+        hval += asso_values[str[0]];
+    }
+  return hval + asso_values[str[len - 1]];
+}
+
+static struct resword wordlist[] =
+{
+  {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
+  {"",}, 
+  {"int",  TYPESPEC, RID_INT},
+  {"",}, {"",}, 
+  {"__typeof__",  TYPEOF, NORID},
+  {"__signed__",  TYPESPEC, RID_SIGNED},
+  {"__imag__",  IMAGPART, NORID},
+  {"switch",  SWITCH, NORID},
+  {"__inline__",  SCSPEC, RID_INLINE},
+  {"else",  ELSE, NORID},
+  {"__iterator__",  SCSPEC, RID_ITERATOR},
+  {"__inline",  SCSPEC, RID_INLINE},
+  {"__extension__",  EXTENSION, NORID},
+  {"struct",  STRUCT, NORID},
+  {"__real__",  REALPART, NORID},
+  {"__const",  TYPE_QUAL, RID_CONST},
+  {"while",  WHILE, NORID},
+  {"__const__",  TYPE_QUAL, RID_CONST},
+  {"case",  CASE, NORID},
+  {"__complex__",  TYPESPEC, RID_COMPLEX},
+  {"__iterator",  SCSPEC, RID_ITERATOR},
+  {"bycopy",  TYPE_QUAL, RID_BYCOPY},
+  {"",}, {"",}, {"",}, 
+  {"__complex",  TYPESPEC, RID_COMPLEX},
+  {"",}, 
+  {"in",  TYPE_QUAL, RID_IN},
+  {"break",  BREAK, NORID},
+  {"@defs",  DEFS, NORID},
+  {"",}, {"",}, {"",}, 
+  {"extern",  SCSPEC, RID_EXTERN},
+  {"if",  IF, NORID},
+  {"typeof",  TYPEOF, NORID},
+  {"typedef",  SCSPEC, RID_TYPEDEF},
+  {"__typeof",  TYPEOF, NORID},
+  {"sizeof",  SIZEOF, NORID},
+  {"",}, 
+  {"return",  RETURN, NORID},
+  {"const",  TYPE_QUAL, RID_CONST},
+  {"__volatile__",  TYPE_QUAL, RID_VOLATILE},
+  {"@private",  PRIVATE, NORID},
+  {"@selector",  SELECTOR, NORID},
+  {"__volatile",  TYPE_QUAL, RID_VOLATILE},
+  {"__asm__",  ASM_KEYWORD, NORID},
+  {"",}, {"",}, 
+  {"continue",  CONTINUE, NORID},
+  {"__alignof__",  ALIGNOF, NORID},
+  {"__imag",  IMAGPART, NORID},
+  {"__attribute__",  ATTRIBUTE, NORID},
+  {"",}, {"",}, 
+  {"__attribute",  ATTRIBUTE, NORID},
+  {"for",  FOR, NORID},
+  {"",}, 
+  {"@encode",  ENCODE, NORID},
+  {"id",  OBJECTNAME, RID_ID},
+  {"static",  SCSPEC, RID_STATIC},
+  {"@interface",  INTERFACE, NORID},
+  {"",}, 
+  {"__signed",  TYPESPEC, RID_SIGNED},
+  {"",}, 
+  {"__label__",  LABEL, NORID},
+  {"",}, {"",}, 
+  {"__asm",  ASM_KEYWORD, NORID},
+  {"char",  TYPESPEC, RID_CHAR},
+  {"",}, 
+  {"inline",  SCSPEC, RID_INLINE},
+  {"out",  TYPE_QUAL, RID_OUT},
+  {"register",  SCSPEC, RID_REGISTER},
+  {"__real",  REALPART, NORID},
+  {"short",  TYPESPEC, RID_SHORT},
+  {"",}, 
+  {"enum",  ENUM, NORID},
+  {"inout",  TYPE_QUAL, RID_INOUT},
+  {"",}, 
+  {"oneway",  TYPE_QUAL, RID_ONEWAY},
+  {"union",  UNION, NORID},
+  {"",}, 
+  {"__alignof",  ALIGNOF, NORID},
+  {"",}, 
+  {"@implementation",  IMPLEMENTATION, NORID},
+  {"",}, 
+  {"@class",  CLASS, NORID},
+  {"",}, 
+  {"@public",  PUBLIC, NORID},
+  {"asm",  ASM_KEYWORD, NORID},
+  {"",}, {"",}, {"",}, {"",}, {"",}, 
+  {"default",  DEFAULT, NORID},
+  {"",}, 
+  {"void",  TYPESPEC, RID_VOID},
+  {"",}, 
+  {"@protected",  PROTECTED, NORID},
+  {"@protocol",  PROTOCOL, NORID},
+  {"",}, {"",}, {"",}, 
+  {"volatile",  TYPE_QUAL, RID_VOLATILE},
+  {"",}, {"",}, 
+  {"signed",  TYPESPEC, RID_SIGNED},
+  {"float",  TYPESPEC, RID_FLOAT},
+  {"@end",  END, NORID},
+  {"",}, {"",}, 
+  {"unsigned",  TYPESPEC, RID_UNSIGNED},
+  {"@compatibility_alias",  ALIAS, NORID},
+  {"double",  TYPESPEC, RID_DOUBLE},
+  {"",}, {"",}, 
+  {"auto",  SCSPEC, RID_AUTO},
+  {"",}, 
+  {"goto",  GOTO, NORID},
+  {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
+  {"do",  DO, NORID},
+  {"",}, {"",}, {"",}, {"",}, 
+  {"long",  TYPESPEC, RID_LONG},
+};
+
+#ifdef __GNUC__
+__inline
+#endif
+struct resword *
+is_reserved_word (str, len)
+     register char *str;
+     register unsigned int len;
+{
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register char *s = wordlist[key].name;
+
+          if (*s == *str && !strcmp (str + 1, s + 1))
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}
+
+/* Return something to represent absolute declarators containing a *.
+   TARGET is the absolute declarator that the * contains.
+   TYPE_QUALS is a list of modifiers such as const or volatile
+   to apply to the pointer type, represented as identifiers.
+
+   We return an INDIRECT_REF whose "contents" are TARGET
+   and whose type is the modifier list.  */
+
+tree
+make_pointer_declarator (type_quals, target)
+     tree type_quals, target;
+{
+  return build1 (INDIRECT_REF, type_quals, target);
+}
+
+void
+forget_protocol_qualifiers ()
+{
+  int i, n = sizeof wordlist / sizeof (struct resword);
+
+  for (i = 0; i < n; i++)
+    if ((int) wordlist[i].rid >= (int) RID_IN
+        && (int) wordlist[i].rid <= (int) RID_ONEWAY)
+      wordlist[i].name = "";
+}
+
+void
+remember_protocol_qualifiers ()
+{
+  int i, n = sizeof wordlist / sizeof (struct resword);
+
+  for (i = 0; i < n; i++)
+    if (wordlist[i].rid == RID_IN)
+      wordlist[i].name = "in";
+    else if (wordlist[i].rid == RID_OUT)
+      wordlist[i].name = "out";
+    else if (wordlist[i].rid == RID_INOUT)
+      wordlist[i].name = "inout";
+    else if (wordlist[i].rid == RID_BYCOPY)
+      wordlist[i].name = "bycopy";
+    else if (wordlist[i].rid == RID_ONEWAY)
+      wordlist[i].name = "oneway";   
+}
+
+void
+init_lex ()
+{
+  /* Make identifier nodes long enough for the language-specific slots.  */
+  set_identifier_size (sizeof (struct lang_identifier));
+
+  /* Start it at 0, because check_newline is called at the very beginning
+     and will increment it to 1.  */
+  lineno = 0;
+
+#ifdef MULTIBYTE_CHARS
+  /* Change to the native locale for multibyte conversions.  */
+  setlocale (LC_CTYPE, "");
+#endif
+
+  maxtoken = 40;
+  token_buffer = (char *) xmalloc (maxtoken + 2);
+
+  ridpointers[(int) RID_INT] = get_identifier ("int");
+  ridpointers[(int) RID_CHAR] = get_identifier ("char");
+  ridpointers[(int) RID_VOID] = get_identifier ("void");
+  ridpointers[(int) RID_FLOAT] = get_identifier ("float");
+  ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
+  ridpointers[(int) RID_SHORT] = get_identifier ("short");
+  ridpointers[(int) RID_LONG] = get_identifier ("long");
+  ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
+  ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
+  ridpointers[(int) RID_INLINE] = get_identifier ("inline");
+  ridpointers[(int) RID_CONST] = get_identifier ("const");
+  ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
+  ridpointers[(int) RID_AUTO] = get_identifier ("auto");
+  ridpointers[(int) RID_STATIC] = get_identifier ("static");
+  ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
+  ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
+  ridpointers[(int) RID_REGISTER] = get_identifier ("register");
+  ridpointers[(int) RID_ITERATOR] = get_identifier ("iterator");
+  ridpointers[(int) RID_COMPLEX] = get_identifier ("complex");
+  ridpointers[(int) RID_ID] = get_identifier ("id");
+  ridpointers[(int) RID_IN] = get_identifier ("in");
+  ridpointers[(int) RID_OUT] = get_identifier ("out");
+  ridpointers[(int) RID_INOUT] = get_identifier ("inout");
+  ridpointers[(int) RID_BYCOPY] = get_identifier ("bycopy");
+  ridpointers[(int) RID_ONEWAY] = get_identifier ("oneway");
+  forget_protocol_qualifiers();
+
+  /* Some options inhibit certain reserved words.
+     Clear those words out of the hash table so they won't be recognized.  */
+#define UNSET_RESERVED_WORD(STRING) \
+  do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
+       if (s) s->name = ""; } while (0)
+
+  if (! doing_objc_thang)
+    UNSET_RESERVED_WORD ("id");
+
+  if (flag_traditional)
+    {
+      UNSET_RESERVED_WORD ("const");
+      UNSET_RESERVED_WORD ("volatile");
+      UNSET_RESERVED_WORD ("typeof");
+      UNSET_RESERVED_WORD ("signed");
+      UNSET_RESERVED_WORD ("inline");
+      UNSET_RESERVED_WORD ("iterator");
+      UNSET_RESERVED_WORD ("complex");
+    }
+  if (flag_no_asm)
+    {
+      UNSET_RESERVED_WORD ("asm");
+      UNSET_RESERVED_WORD ("typeof");
+      UNSET_RESERVED_WORD ("inline");
+      UNSET_RESERVED_WORD ("iterator");
+      UNSET_RESERVED_WORD ("complex");
+    }
+}
+
+void
+reinit_parse_for_function ()
+{
+}
+
+/* Function used when yydebug is set, to print a token in more detail.  */
+
+void
+yyprint (file, yychar, yylval)
+     FILE *file;
+     int yychar;
+     YYSTYPE yylval;
+{
+  tree t;
+  switch (yychar)
+    {
+    case IDENTIFIER:
+    case TYPENAME:
+    case OBJECTNAME:
+      t = yylval.ttype;
+      if (IDENTIFIER_POINTER (t))
+	fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
+      break;
+
+    case CONSTANT:
+      t = yylval.ttype;
+      if (TREE_CODE (t) == INTEGER_CST)
+	fprintf (file,
+#if HOST_BITS_PER_WIDE_INT == 64
+#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
+		 " 0x%lx%016lx",
+#else
+		 " 0x%x%016x",
+#endif
+#else
+#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
+		 " 0x%lx%08lx",
+#else
+		 " 0x%x%08x",
+#endif
+#endif
+		 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
+      break;
+    }
+}
+
+
+/* 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;
+{
+  static int newline_warning = 0;
+
+  for (;;)
+    {
+      switch (c)
+	{
+	  /* We don't recognize comments here, because
+	     cpp output can include / and * consecutively as operators.
+	     Also, there's no need, since cpp removes all comments.  */
+
+	case '\n':
+	  c = check_newline ();
+	  break;
+
+	case ' ':
+	case '\t':
+	case '\f':
+	case '\v':
+	case '\b':
+	  c = getc (finput);
+	  break;
+
+	case '\r':
+	  /* ANSI C says the effects of a carriage return in a source file
+	     are undefined.  */
+	  if (pedantic && !newline_warning)
+	    {
+	      warning ("carriage return in source file");
+	      warning ("(we only warn about the first carriage return)");
+	      newline_warning = 1;
+	    }
+	  c = getc (finput);
+	  break;
+
+	case '\\':
+	  c = getc (finput);
+	  if (c == '\n')
+	    lineno++;
+	  else
+	    error ("stray '\\' in program");
+	  c = getc (finput);
+	  break;
+
+	default:
+	  return (c);
+	}
+    }
+}
+
+/* Skips all of the white space at the current location in the input file.
+   Must use and reset nextchar if it has the next character.  */
+
+void
+position_after_white_space ()
+{
+  register int c;
+
+  if (nextchar != -1)
+    c = nextchar, nextchar = -1;
+  else
+    c = getc (finput);
+
+  ungetc (skip_white_space (c), finput);
+}
+
+/* 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 char *
+extend_token_buffer (p)
+     char *p;
+{
+  int offset = p - token_buffer;
+
+  maxtoken = maxtoken * 2 + 10;
+  token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
+
+  return token_buffer + offset;
+}
+
+/* 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;
+  register int token;
+
+  lineno++;
+
+  /* Read first nonwhite char on the line.  */
+
+  c = getc (finput);
+  while (c == ' ' || c == '\t')
+    c = getc (finput);
+
+  if (c != '#')
+    {
+      /* If not #, return it so caller will use it.  */
+      return c;
+    }
+
+  /* Read first nonwhite char after the `#'.  */
+
+  c = getc (finput);
+  while (c == ' ' || c == '\t')
+    c = getc (finput);
+
+  /* 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', `ident', `define', or `undef'.  */
+
+  if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+    {
+      if (c == 'p')
+	{
+	  if (getc (finput) == 'r'
+	      && getc (finput) == 'a'
+	      && getc (finput) == 'g'
+	      && getc (finput) == 'm'
+	      && getc (finput) == 'a'
+	      && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
+	    {
+#ifdef HANDLE_SYSV_PRAGMA
+	      return handle_sysv_pragma (finput, c);
+#endif /* HANDLE_SYSV_PRAGMA */
+#ifdef HANDLE_PRAGMA
+	      HANDLE_PRAGMA (finput);
+#endif /* HANDLE_PRAGMA */
+	      goto skipline;
+	    }
+	}
+
+      else if (c == 'd')
+	{
+	  if (getc (finput) == 'e'
+	      && getc (finput) == 'f'
+	      && getc (finput) == 'i'
+	      && getc (finput) == 'n'
+	      && getc (finput) == 'e'
+	      && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
+	    {
+#ifdef DWARF_DEBUGGING_INFO
+	      if ((debug_info_level == DINFO_LEVEL_VERBOSE)
+		  && (write_symbols == DWARF_DEBUG))
+	        dwarfout_define (lineno, get_directive_line (finput));
+#endif /* DWARF_DEBUGGING_INFO */
+	      goto skipline;
+	    }
+	}
+      else if (c == 'u')
+	{
+	  if (getc (finput) == 'n'
+	      && getc (finput) == 'd'
+	      && getc (finput) == 'e'
+	      && getc (finput) == 'f'
+	      && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
+	    {
+#ifdef DWARF_DEBUGGING_INFO
+	      if ((debug_info_level == DINFO_LEVEL_VERBOSE)
+		  && (write_symbols == DWARF_DEBUG))
+	        dwarfout_undef (lineno, get_directive_line (finput));
+#endif /* DWARF_DEBUGGING_INFO */
+	      goto skipline;
+	    }
+	}
+      else if (c == 'l')
+	{
+	  if (getc (finput) == 'i'
+	      && getc (finput) == 'n'
+	      && getc (finput) == 'e'
+	      && ((c = getc (finput)) == ' ' || c == '\t'))
+	    goto linenum;
+	}
+      else if (c == 'i')
+	{
+	  if (getc (finput) == 'd'
+	      && getc (finput) == 'e'
+	      && getc (finput) == 'n'
+	      && getc (finput) == 't'
+	      && ((c = getc (finput)) == ' ' || c == '\t'))
+	    {
+	      /* #ident.  The pedantic warning is now in cccp.c.  */
+
+	      /* Here we have just seen `#ident '.
+		 A string constant should follow.  */
+
+	      while (c == ' ' || c == '\t')
+		c = getc (finput);
+
+	      /* If no argument, ignore the line.  */
+	      if (c == '\n')
+		return c;
+
+	      ungetc (c, finput);
+	      token = yylex ();
+	      if (token != STRING
+		  || TREE_CODE (yylval.ttype) != STRING_CST)
+		{
+		  error ("invalid #ident");
+		  goto skipline;
+		}
+
+	      if (!flag_no_ident)
+		{
+#ifdef ASM_OUTPUT_IDENT
+		  ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
+#endif
+		}
+
+	      /* Skip the rest of this line.  */
+	      goto skipline;
+	    }
+	}
+
+      error ("undefined or invalid # directive");
+      goto skipline;
+    }
+
+linenum:
+  /* Here we have either `#line' or `# <nonletter>'.
+     In either case, it should be a line number; a digit should follow.  */
+
+  while (c == ' ' || c == '\t')
+    c = getc (finput);
+
+  /* If the # is the only nonwhite char on the line,
+     just ignore it.  Check the new newline.  */
+  if (c == '\n')
+    return c;
+
+  /* Something follows the #; read a token.  */
+
+  ungetc (c, finput);
+  token = yylex ();
+
+  if (token == CONSTANT
+      && TREE_CODE (yylval.ttype) == INTEGER_CST)
+    {
+      int old_lineno = lineno;
+      int used_up = 0;
+      /* subtract one, because it is the following line that
+	 gets the specified number */
+
+      int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
+
+      /* Is this the last nonwhite stuff on the line?  */
+      c = getc (finput);
+      while (c == ' ' || c == '\t')
+	c = getc (finput);
+      if (c == '\n')
+	{
+	  /* No more: store the line number and check following line.  */
+	  lineno = l;
+	  return c;
+	}
+      ungetc (c, finput);
+
+      /* More follows: it must be a string constant (filename).  */
+
+      /* Read the string constant, but don't treat \ as special.  */
+      ignore_escape_flag = 1;
+      token = yylex ();
+      ignore_escape_flag = 0;
+
+      if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
+	{
+	  error ("invalid #line");
+	  goto skipline;
+	}
+
+      input_filename
+	= (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
+      strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
+      lineno = l;
+
+      /* Each change of file name
+	 reinitializes whether we are now in a system header.  */
+      in_system_header = 0;
+
+      if (main_input_filename == 0)
+	main_input_filename = input_filename;
+
+      /* Is this the last nonwhite stuff on the line?  */
+      c = getc (finput);
+      while (c == ' ' || c == '\t')
+	c = getc (finput);
+      if (c == '\n')
+	{
+	  /* Update the name in the top element of input_file_stack.  */
+	  if (input_file_stack)
+	    input_file_stack->name = input_filename;
+
+	  return c;
+	}
+      ungetc (c, finput);
+
+      token = yylex ();
+      used_up = 0;
+
+      /* `1' after file name means entering new file.
+	 `2' after file name means just left a file.  */
+
+      if (token == CONSTANT
+	  && TREE_CODE (yylval.ttype) == INTEGER_CST)
+	{
+	  if (TREE_INT_CST_LOW (yylval.ttype) == 1)
+	    {
+	      /* Pushing to a new file.  */
+	      struct file_stack *p
+		= (struct file_stack *) xmalloc (sizeof (struct file_stack));
+	      input_file_stack->line = old_lineno;
+	      p->next = input_file_stack;
+	      p->name = input_filename;
+	      input_file_stack = p;
+	      input_file_stack_tick++;
+#ifdef DWARF_DEBUGGING_INFO
+	      if (debug_info_level == DINFO_LEVEL_VERBOSE
+		  && write_symbols == DWARF_DEBUG)
+		dwarfout_start_new_source_file (input_filename);
+#endif /* DWARF_DEBUGGING_INFO */
+
+	      used_up = 1;
+	    }
+	  else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
+	    {
+	      /* Popping out of a file.  */
+	      if (input_file_stack->next)
+		{
+		  struct file_stack *p = input_file_stack;
+		  input_file_stack = p->next;
+		  free (p);
+		  input_file_stack_tick++;
+#ifdef DWARF_DEBUGGING_INFO
+		  if (debug_info_level == DINFO_LEVEL_VERBOSE
+		      && write_symbols == DWARF_DEBUG)
+		    dwarfout_resume_previous_source_file (input_file_stack->line);
+#endif /* DWARF_DEBUGGING_INFO */
+		}
+	      else
+		error ("#-lines for entering and leaving files don't match");
+
+	      used_up = 1;
+	    }
+	}
+
+      /* Now that we've pushed or popped the input stack,
+	 update the name in the top element.  */
+      if (input_file_stack)
+	input_file_stack->name = input_filename;
+
+      /* If we have handled a `1' or a `2',
+	 see if there is another number to read.  */
+      if (used_up)
+	{
+	  /* Is this the last nonwhite stuff on the line?  */
+	  c = getc (finput);
+	  while (c == ' ' || c == '\t')
+	    c = getc (finput);
+	  if (c == '\n')
+	    return c;
+	  ungetc (c, finput);
+
+	  token = yylex ();
+	  used_up = 0;
+	}
+
+      /* `3' after file name means this is a system header file.  */
+
+      if (token == CONSTANT
+	  && TREE_CODE (yylval.ttype) == INTEGER_CST
+	  && TREE_INT_CST_LOW (yylval.ttype) == 3)
+	in_system_header = 1;
+    }
+  else
+    error ("invalid #-line");
+
+  /* skip the rest of this line.  */
+ skipline:
+  if (c == '\n')
+    return c;
+  while ((c = getc (finput)) != EOF && c != '\n');
+  return c;
+}
+
+#ifdef HANDLE_SYSV_PRAGMA
+
+/* Handle a #pragma directive.  INPUT is the current input stream,
+   and C is a character to reread.  Processes the entire input line
+   and returns a character for the caller to reread: either \n or EOF.  */
+
+/* This function has to be in this file, in order to get at
+   the token types.  */
+
+int
+handle_sysv_pragma (input, c)
+     FILE *input;
+     int c;
+{
+  for (;;)
+    {
+      while (c == ' ' || c == '\t')
+	c = getc (input);
+      if (c == '\n' || c == EOF)
+	{
+	  handle_pragma_token (0, 0);
+	  return c;
+	}
+      ungetc (c, input);
+      switch (yylex ())
+	{
+	case IDENTIFIER:
+	case TYPENAME:
+	case STRING:
+	case CONSTANT:
+	  handle_pragma_token (token_buffer, yylval.ttype);
+	  break;
+	default:
+	  handle_pragma_token (token_buffer, 0);
+	}
+      if (nextchar >= 0)
+	c = nextchar, nextchar = -1;
+      else
+	c = getc (input);
+    }
+}
+
+#endif /* HANDLE_SYSV_PRAGMA */
+
+#define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
+#define isdigit(char) (char >= '0' && char <= '9')
+#define ENDFILE -1  /* token that represents end-of-file */
+
+/* Read an escape sequence, returning its equivalent as a character,
+   or store 1 in *ignore_ptr if it is backslash-newline.  */
+
+static int
+readescape (ignore_ptr)
+     int *ignore_ptr;
+{
+  register int c = getc (finput);
+  register int code;
+  register unsigned count;
+  unsigned firstdig;
+  int nonnull;
+
+  switch (c)
+    {
+    case 'x':
+      if (warn_traditional)
+	warning ("the meaning of `\\x' varies with -traditional");
+
+      if (flag_traditional)
+	return c;
+
+      code = 0;
+      count = 0;
+      nonnull = 0;
+      while (1)
+	{
+	  c = getc (finput);
+	  if (!(c >= 'a' && c <= 'f')
+	      && !(c >= 'A' && c <= 'F')
+	      && !(c >= '0' && c <= '9'))
+	    {
+	      ungetc (c, finput);
+	      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)
+	error ("\\x used with no following hex digits");
+      else if (count == 0)
+	/* Digits are all 0's.  Ok.  */
+	;
+      else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
+	       || (count > 1
+		   && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
+		       <= firstdig)))
+	pedwarn ("hex escape out of range");
+      return code;
+
+    case '0':  case '1':  case '2':  case '3':  case '4':
+    case '5':  case '6':  case '7':
+      code = 0;
+      count = 0;
+      while ((c <= '7') && (c >= '0') && (count++ < 3))
+	{
+	  code = (code * 8) + (c - '0');
+	  c = getc (finput);
+	}
+      ungetc (c, finput);
+      return code;
+
+    case '\\': case '\'': case '"':
+      return c;
+
+    case '\n':
+      lineno++;
+      *ignore_ptr = 1;
+      return 0;
+
+    case 'n':
+      return TARGET_NEWLINE;
+
+    case 't':
+      return TARGET_TAB;
+
+    case 'r':
+      return TARGET_CR;
+
+    case 'f':
+      return TARGET_FF;
+
+    case 'b':
+      return TARGET_BS;
+
+    case 'a':
+      if (warn_traditional)
+	warning ("the meaning of `\\a' varies with -traditional");
+
+      if (flag_traditional)
+	return c;
+      return TARGET_BELL;
+
+    case 'v':
+#if 0 /* Vertical tab is present in common usage compilers.  */
+      if (flag_traditional)
+	return c;
+#endif
+      return TARGET_VT;
+
+    case 'e':
+    case 'E':
+      if (pedantic)
+	pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
+      return 033;
+
+    case '?':
+      return c;
+
+      /* `\(', etc, are used at beginning of line to avoid confusing Emacs.  */
+    case '(':
+    case '{':
+    case '[':
+      /* `\%' is used to prevent SCCS from getting confused.  */
+    case '%':
+      if (pedantic)
+	pedwarn ("non-ANSI escape sequence `\\%c'", c);
+      return c;
+    }
+  if (c >= 040 && c < 0177)
+    pedwarn ("unknown escape sequence `\\%c'", c);
+  else
+    pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
+  return c;
+}
+
+void
+yyerror (string)
+     char *string;
+{
+  char buf[200];
+
+  strcpy (buf, string);
+
+  /* We can't print string and character constants well
+     because the token_buffer contains the result of processing escapes.  */
+  if (end_of_file)
+    strcat (buf, " at end of input");
+  else if (token_buffer[0] == 0)
+    strcat (buf, " at null character");
+  else if (token_buffer[0] == '"')
+    strcat (buf, " before string constant");
+  else if (token_buffer[0] == '\'')
+    strcat (buf, " before character constant");
+  else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
+    sprintf (buf + strlen (buf), " before character 0%o",
+	     (unsigned char) token_buffer[0]);
+  else
+    strcat (buf, " before `%s'");
+
+  error (buf, token_buffer);
+}
+
+#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 */
+
+int
+yylex ()
+{
+  register int c;
+  register char *p;
+  register int value;
+  int wide_flag = 0;
+  int objc_flag = 0;
+
+  if (nextchar >= 0)
+    c = nextchar, nextchar = -1;
+  else
+    c = getc (finput);
+
+  /* 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':
+      case '\b':
+	c = getc (finput);
+	break;
+
+      case '\r':
+	/* Call skip_white_space so we can warn if appropriate.  */
+
+      case '\n':
+      case '/':
+      case '\\':
+	c = skip_white_space (c);
+      default:
+	goto found_nonwhite;
+      }
+ found_nonwhite:
+
+  token_buffer[0] = c;
+  token_buffer[1] = 0;
+
+/*  yylloc.first_line = lineno; */
+
+  switch (c)
+    {
+    case EOF:
+      end_of_file = 1;
+      token_buffer[0] = 0;
+      value = ENDFILE;
+      break;
+
+    case '$':
+      if (dollars_in_ident)
+	goto letter;
+      return '$';
+
+    case 'L':
+      /* Capital L may start a wide-string or wide-character constant.  */
+      {
+	register int c = getc (finput);
+	if (c == '\'')
+	  {
+	    wide_flag = 1;
+	    goto char_constant;
+	  }
+	if (c == '"')
+	  {
+	    wide_flag = 1;
+	    goto string_constant;
+	  }
+	ungetc (c, finput);
+      }
+      goto letter;
+
+    case '@':
+      if (!doing_objc_thang)
+	{
+	  value = c;
+	  break;
+	}
+      else
+	{
+	  /* '@' may start a constant string object.  */
+	  register int c = getc(finput);
+	  if (c == '"')
+	    {
+	      objc_flag = 1;
+	      goto string_constant;
+	    }
+	  ungetc(c, finput);
+	  /* Fall through to treat '@' as the start of an indentifier.  */
+	}
+
+    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 '_':
+    letter:
+      p = token_buffer;
+      while (isalnum (c) || c == '_' || c == '$' || c == '@')
+	{
+	  /* Make sure this char really belongs in an identifier.  */
+	  if (c == '@' && ! doing_objc_thang)
+	    break;
+	  if (c == '$' && ! dollars_in_ident)
+	    break;
+
+	  if (p >= token_buffer + maxtoken)
+	    p = extend_token_buffer (p);
+
+	  *p++ = c;
+	  c = getc (finput);
+	}
+
+      *p = 0;
+      nextchar = c;
+
+      value = IDENTIFIER;
+      yylval.itype = 0;
+
+      /* Try to recognize a keyword.  Uses minimum-perfect hash function */
+
+      {
+	register struct resword *ptr;
+
+	if (ptr = is_reserved_word (token_buffer, p - token_buffer))
+	  {
+	    if (ptr->rid)
+	      yylval.ttype = ridpointers[(int) ptr->rid];
+	    value = (int) ptr->token;
+
+	    /* Only return OBJECTNAME if it is a typedef.  */
+	    if (doing_objc_thang && value == OBJECTNAME)
+	      {
+		lastiddecl = lookup_name(yylval.ttype);
+
+		if (lastiddecl == NULL_TREE
+		    || TREE_CODE (lastiddecl) != TYPE_DECL)
+		  value = IDENTIFIER;
+	      }
+
+	    /* Even if we decided to recognize asm, still perhaps warn.  */
+	    if (pedantic
+		&& (value == ASM_KEYWORD || value == TYPEOF
+		    || ptr->rid == RID_INLINE)
+		&& token_buffer[0] != '_')
+	      pedwarn ("ANSI does not permit the keyword `%s'",
+		       token_buffer);
+	  }
+      }
+
+      /* If we did not find a keyword, look for an identifier
+	 (or a typename).  */
+
+      if (value == IDENTIFIER)
+	{
+ 	  if (token_buffer[0] == '@')
+	    error("invalid identifier `%s'", token_buffer);
+
+          yylval.ttype = get_identifier (token_buffer);
+	  lastiddecl = lookup_name (yylval.ttype);
+
+	  if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
+	    value = TYPENAME;
+	  /* A user-invisible read-only initialized variable
+	     should be replaced by its value.
+	     We handle only strings since that's the only case used in C.  */
+	  else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
+		   && DECL_IGNORED_P (lastiddecl)
+		   && TREE_READONLY (lastiddecl)
+		   && DECL_INITIAL (lastiddecl) != 0
+		   && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
+	    {
+	      tree stringval = DECL_INITIAL (lastiddecl);
+	      
+	      /* Copy the string value so that we won't clobber anything
+		 if we put something in the TREE_CHAIN of this one.  */
+	      yylval.ttype = build_string (TREE_STRING_LENGTH (stringval),
+					   TREE_STRING_POINTER (stringval));
+	      value = STRING;
+	    }
+          else if (doing_objc_thang)
+            {
+	      tree objc_interface_decl = is_class_name (yylval.ttype);
+
+	      if (objc_interface_decl)
+		{
+		  value = CLASSNAME;
+		  yylval.ttype = objc_interface_decl;
+		}
+	    }
+	}
+
+      break;
+
+    case '0':  case '1':  case '2':  case '3':  case '4':
+    case '5':  case '6':  case '7':  case '8':  case '9':
+    case '.':
+      {
+	int base = 10;
+	int count = 0;
+	int largest_digit = 0;
+	int numdigits = 0;
+	/* for multi-precision arithmetic,
+	   we actually store only HOST_BITS_PER_CHAR bits in each part.
+	   The number of parts is chosen so as to be sufficient to hold
+	   the enough bits to fit into the two HOST_WIDE_INTs that contain
+	   the integer value (this is always at least as many bits as are
+	   in a target `long long' value, but may be wider).  */
+#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
+	int parts[TOTAL_PARTS];
+	int overflow = 0;
+
+	enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
+	  = NOT_FLOAT;
+
+	for (count = 0; count < TOTAL_PARTS; count++)
+	  parts[count] = 0;
+
+	p = token_buffer;
+	*p++ = c;
+
+	if (c == '0')
+	  {
+	    *p++ = (c = getc (finput));
+	    if ((c == 'x') || (c == 'X'))
+	      {
+		base = 16;
+		*p++ = (c = getc (finput));
+	      }
+	    /* Leading 0 forces octal unless the 0 is the only digit.  */
+	    else if (c >= '0' && c <= '9')
+	      {
+		base = 8;
+		numdigits++;
+	      }
+	    else
+	      numdigits++;
+	  }
+
+	/* Read all the digits-and-decimal-points.  */
+
+	while (c == '.'
+	       || (isalnum (c) && c != 'l' && c != 'L'
+		   && c != 'u' && c != 'U'
+		   && c != 'i' && c != 'I' && c != 'j' && c != 'J'
+		   && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
+	  {
+	    if (c == '.')
+	      {
+		if (base == 16)
+		  error ("floating constant may not be in radix 16");
+		if (floatflag == AFTER_POINT)
+		  {
+		    error ("malformed floating constant");
+		    floatflag = TOO_MANY_POINTS;
+		  }
+		else
+		  floatflag = AFTER_POINT;
+
+		base = 10;
+		*p++ = c = getc (finput);
+		/* Accept '.' as the start of a floating-point number
+		   only when it is followed by a digit.
+		   Otherwise, unread the following non-digit
+		   and use the '.' as a structural token.  */
+		if (p == token_buffer + 2 && !isdigit (c))
+		  {
+		    if (c == '.')
+		      {
+			c = getc (finput);
+			if (c == '.')
+			  {
+			    *p++ = c;
+			    *p = 0;
+			    return ELLIPSIS;
+			  }
+			error ("parse error at `..'");
+		      }
+		    ungetc (c, finput);
+		    token_buffer[1] = 0;
+		    value = '.';
+		    goto done;
+		  }
+	      }
+	    else
+	      {
+		/* It is not a decimal point.
+		   It should be a digit (perhaps a hex digit).  */
+
+		if (isdigit (c))
+		  {
+		    c = c - '0';
+		  }
+		else if (base <= 10)
+		  {
+		    if (c == 'e' || c == 'E')
+		      {
+			base = 10;
+			floatflag = AFTER_POINT;
+			break;   /* start of exponent */
+		      }
+		    error ("nondigits in number and not hexadecimal");
+		    c = 0;
+		  }
+		else if (c >= 'a')
+		  {
+		    c = c - 'a' + 10;
+		  }
+		else
+		  {
+		    c = c - 'A' + 10;
+		  }
+		if (c >= largest_digit)
+		  largest_digit = c;
+		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] += c;
+		  }
+
+		/* If the extra highest-order part ever gets anything in it,
+		   the number is certainly too big.  */
+		if (parts[TOTAL_PARTS - 1] != 0)
+		  overflow = 1;
+
+		if (p >= token_buffer + maxtoken - 3)
+		  p = extend_token_buffer (p);
+		*p++ = (c = getc (finput));
+	      }
+	  }
+
+	if (numdigits == 0)
+	  error ("numeric constant with no digits");
+
+	if (largest_digit >= base)
+	  error ("numeric constant contains digits beyond the radix");
+
+	/* Remove terminating char from the token buffer and delimit the string */
+	*--p = 0;
+
+	if (floatflag != NOT_FLOAT)
+	  {
+	    tree type = double_type_node;
+	    int garbage_chars = 0, exceeds_double = 0;
+	    int imag = 0;
+	    REAL_VALUE_TYPE value;
+	    jmp_buf handler;
+
+	    /* Read explicit exponent if any, and put it in tokenbuf.  */
+
+	    if ((c == 'e') || (c == 'E'))
+	      {
+		if (p >= token_buffer + maxtoken - 3)
+		  p = extend_token_buffer (p);
+		*p++ = c;
+		c = getc (finput);
+		if ((c == '+') || (c == '-'))
+		  {
+		    *p++ = c;
+		    c = getc (finput);
+		  }
+		if (! isdigit (c))
+		  error ("floating constant exponent has no digits");
+	        while (isdigit (c))
+		  {
+		    if (p >= token_buffer + maxtoken - 3)
+		      p = extend_token_buffer (p);
+		    *p++ = c;
+		    c = getc (finput);
+		  }
+	      }
+
+	    *p = 0;
+	    errno = 0;
+
+	    /* Convert string to a double, checking for overflow.  */
+	    if (setjmp (handler))
+	      {
+		error ("floating constant out of range");
+		value = dconst0;
+	      }
+	    else
+	      {
+		set_float_handler (handler);
+
+/* The second argument, machine_mode, of REAL_VALUE_ATOF tells the
+   desired precision of the binary result of decimal-to-binary conversion.  */
+
+	    /* Read the suffixes to choose a data type.  */
+	    switch (c)
+	      {
+	      case 'f': case 'F':
+		type = float_type_node;
+		value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
+		if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
+		    && REAL_VALUE_ISINF (value) && pedantic)
+		  pedwarn ("floating point number exceeds range of `float'");
+		garbage_chars = -1;
+		break;
+
+	      case 'l': case 'L':
+		type = long_double_type_node;
+		value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
+		if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
+		    && REAL_VALUE_ISINF (value) && pedantic)
+		  pedwarn (
+		      "floating point number exceeds range of `long double'");
+		garbage_chars = -1;
+		break;
+
+	      case 'i': case 'I':
+		if (imag)
+		  error ("more than one `i' or `j' in numeric constant");
+		imag = 1;
+		garbage_chars = -1;
+		break;
+
+              default:
+		value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
+		if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
+		    && REAL_VALUE_ISINF (value) && pedantic)
+		  pedwarn ("floating point number exceeds range of `double'");
+	      }
+	    set_float_handler (NULL_PTR);
+	    }
+#ifdef ERANGE
+	    if (errno == ERANGE && !flag_traditional && pedantic)
+	      {
+  		/* ERANGE is also reported for underflow,
+  		   so test the value to distinguish overflow from that.  */
+		if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
+		    && (REAL_VALUES_LESS (dconst1, value)
+			|| REAL_VALUES_LESS (value, dconstm1)))
+		  {
+		    pedwarn ("floating point number exceeds range of `double'");
+		    exceeds_double = 1;
+		  }
+	      }
+#endif
+	    /* Note: garbage_chars is -1 if first char is *not* garbage.  */
+	    while (isalnum (c) || c == '.' || c == '_'
+		   || (!flag_traditional && (c == '+' || c == '-')
+		       && (p[-1] == 'e' || p[-1] == 'E')))
+	      {
+		if (p >= token_buffer + maxtoken - 3)
+		  p = extend_token_buffer (p);
+		*p++ = c;
+		c = getc (finput);
+		garbage_chars++;
+	      }
+	    if (garbage_chars > 0)
+	      error ("garbage at end of number");
+
+	    /* Create a node with determined type and value.  */
+	    if (imag)
+	      yylval.ttype = build_complex (convert (type, integer_zero_node),
+					    build_real (type, value));
+	    else
+	      yylval.ttype = build_real (type, value);
+
+	    ungetc (c, finput);
+	    *p = 0;
+	  }
+	else
+	  {
+	    tree traditional_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 bytes, warn, i;
+
+	    while (1)
+	      {
+		if (c == 'u' || c == 'U')
+		  {
+		    if (spec_unsigned)
+		      error ("two `u's in integer constant");
+		    spec_unsigned = 1;
+		  }
+		else if (c == 'l' || c == 'L')
+		  {
+		    if (spec_long)
+		      {
+			if (spec_long_long)
+			  error ("three `l's in integer constant");
+			else if (pedantic)
+			  pedwarn ("ANSI C forbids long long integer constants");
+			spec_long_long = 1;
+		      }
+		    spec_long = 1;
+		  }
+		else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
+		  {
+		    if (spec_imag)
+		      error ("more than one `i' or `j' in numeric constant");
+		    spec_imag = 1;
+		  }
+		else
+		  {
+		    if (isalnum (c) || c == '.' || c == '_'
+			|| (!flag_traditional && (c == '+' || c == '-')
+			    && (p[-1] == 'e' || p[-1] == 'E')))
+		      {
+			error ("garbage at end of number");
+			while (isalnum (c) || c == '.' || c == '_'
+			       || (!flag_traditional && (c == '+' || c == '-')
+				   && (p[-1] == 'e' || p[-1] == 'E')))
+			  {
+			    if (p >= token_buffer + maxtoken - 3)
+			      p = extend_token_buffer (p);
+			    *p++ = c;
+			    c = getc (finput);
+			  }
+		      }
+		    break;
+		  }
+		if (p >= token_buffer + maxtoken - 3)
+		  p = extend_token_buffer (p);
+		*p++ = c;
+		c = getc (finput);
+	      }
+
+	    ungetc (c, finput);
+
+	    /* If the constant is not long long and it won't fit in an
+	       unsigned long, or if the constant is long long and won't fit
+	       in an unsigned long long, then warn that the constant is out
+	       of range.  */
+
+	    /* ??? This assumes that long long and long integer types are
+	       a multiple of 8 bits.  This better than the original code
+	       though which assumed that long was exactly 32 bits and long
+	       long was exactly 64 bits.  */
+
+	    if (spec_long_long)
+	      bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
+	    else
+	      bytes = TYPE_PRECISION (long_integer_type_node) / 8;
+
+	    warn = overflow;
+	    for (i = bytes; i < TOTAL_PARTS; i++)
+	      if (parts[i])
+		warn = 1;
+	    if (warn)
+	      pedwarn ("integer constant out of range");
+
+	    /* 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);
+	      }
+	    
+	    yylval.ttype = build_int_2 (low, high);
+	    TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
+
+	    /* If warn_traditional, calculate both the ANSI 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 (yylval.ttype, unsigned_type_node))
+		  traditional_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 (yylval.ttype, integer_type_node))
+		  traditional_type = (spec_unsigned ? unsigned_type_node
+				      : integer_type_node);
+		else if (! spec_long_long)
+		  traditional_type = (spec_unsigned ? long_unsigned_type_node
+				      : long_integer_type_node);
+		else
+		  traditional_type = (spec_unsigned
+				      ? long_long_unsigned_type_node
+				      : long_long_integer_type_node);
+	      }
+	    if (warn_traditional || ! flag_traditional)
+	      {
+		/* Calculate the ANSI type.  */
+		if (! spec_long && ! spec_unsigned
+		    && int_fits_type_p (yylval.ttype, integer_type_node))
+		  ansi_type = integer_type_node;
+		else if (! spec_long && (base != 10 || spec_unsigned)
+			 && int_fits_type_p (yylval.ttype, unsigned_type_node))
+		  ansi_type = unsigned_type_node;
+		else if (! spec_unsigned && !spec_long_long
+			 && int_fits_type_p (yylval.ttype, long_integer_type_node))
+		  ansi_type = long_integer_type_node;
+		else if (! spec_long_long)
+		  ansi_type = long_unsigned_type_node;
+		else if (! spec_unsigned
+			 /* Verify value does not overflow into sign bit.  */
+			 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
+			 && int_fits_type_p (yylval.ttype,
+					     long_long_integer_type_node))
+		  ansi_type = long_long_integer_type_node;
+		else
+		  ansi_type = long_long_unsigned_type_node;
+	      }
+
+	    type = flag_traditional ? traditional_type : ansi_type;
+
+	    if (warn_traditional && traditional_type != ansi_type)
+	      {
+		if (TYPE_PRECISION (traditional_type)
+		    != TYPE_PRECISION (ansi_type))
+		  warning ("width of integer constant changes with -traditional");
+		else if (TREE_UNSIGNED (traditional_type)
+			 != TREE_UNSIGNED (ansi_type))
+		  warning ("integer constant is unsigned in ANSI C, signed with -traditional");
+		else
+		  warning ("width of integer constant may change on other systems with -traditional");
+	      }
+
+	    if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
+		&& !warn)
+	      pedwarn ("integer constant out of range");
+
+	    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))
+		  yylval.ttype
+		    = build_complex (integer_zero_node,
+				     convert (integer_type_node, yylval.ttype));
+		else
+		  error ("complex integer constant is too wide for `complex int'");
+	      }
+	    else if (flag_traditional && !int_fits_type_p (yylval.ttype, 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 (yylval.ttype) = unsigned_type (type);
+		yylval.ttype = convert (type, yylval.ttype);
+	      }
+	    else
+	      TREE_TYPE (yylval.ttype) = type;
+
+	    *p = 0;
+	  }
+
+	value = CONSTANT; break;
+      }
+
+    case '\'':
+    char_constant:
+      {
+	register int result = 0;
+	register int num_chars = 0;
+	unsigned width = TYPE_PRECISION (char_type_node);
+	int max_chars;
+
+	if (wide_flag)
+	  {
+	    width = WCHAR_TYPE_SIZE;
+#ifdef MULTIBYTE_CHARS
+	    max_chars = MB_CUR_MAX;
+#else
+	    max_chars = 1;
+#endif
+	  }
+	else
+	  max_chars = TYPE_PRECISION (integer_type_node) / width;
+
+	while (1)
+	  {
+	  tryagain:
+
+	    c = getc (finput);
+
+	    if (c == '\'' || c == EOF)
+	      break;
+
+	    if (c == '\\')
+	      {
+		int ignore = 0;
+		c = readescape (&ignore);
+		if (ignore)
+		  goto tryagain;
+		if (width < HOST_BITS_PER_INT
+		    && (unsigned) c >= (1 << width))
+		  pedwarn ("escape sequence out of range for character");
+#ifdef MAP_CHARACTER
+		if (isprint (c))
+		  c = MAP_CHARACTER (c);
+#endif
+	      }
+	    else if (c == '\n')
+	      {
+		if (pedantic)
+		  pedwarn ("ANSI C forbids newline in character constant");
+		lineno++;
+	      }
+#ifdef MAP_CHARACTER
+	    else
+	      c = MAP_CHARACTER (c);
+#endif
+
+	    num_chars++;
+	    if (num_chars > maxtoken - 4)
+	      extend_token_buffer (token_buffer);
+
+	    token_buffer[num_chars] = c;
+
+	    /* Merge character into result; ignore excess chars.  */
+	    if (num_chars < max_chars + 1)
+	      {
+		if (width < HOST_BITS_PER_INT)
+		  result = (result << width) | (c & ((1 << width) - 1));
+		else
+		  result = c;
+	      }
+	  }
+
+	token_buffer[num_chars + 1] = '\'';
+	token_buffer[num_chars + 2] = 0;
+
+	if (c != '\'')
+	  error ("malformatted character constant");
+	else if (num_chars == 0)
+	  error ("empty character constant");
+	else if (num_chars > max_chars)
+	  {
+	    num_chars = max_chars;
+	    error ("character constant too long");
+	  }
+	else if (num_chars != 1 && ! flag_traditional)
+	  warning ("multi-character character constant");
+
+	/* If char type is signed, sign-extend the constant.  */
+	if (! wide_flag)
+	  {
+	    int num_bits = num_chars * width;
+	    if (num_bits == 0)
+	      /* We already got an error; avoid invalid shift.  */
+	      yylval.ttype = build_int_2 (0, 0);
+	    else if (TREE_UNSIGNED (char_type_node)
+		     || ((result >> (num_bits - 1)) & 1) == 0)
+	      yylval.ttype
+		= build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
+					 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
+			       0);
+	    else
+	      yylval.ttype
+		= build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
+					  >> (HOST_BITS_PER_WIDE_INT - num_bits)),
+			       -1);
+	    TREE_TYPE (yylval.ttype) = integer_type_node;
+	  }
+	else
+	  {
+#ifdef MULTIBYTE_CHARS
+	    /* Set the initial shift state and convert the next sequence.  */
+	    result = 0;
+	    /* In all locales L'\0' is zero and mbtowc will return zero,
+	       so don't use it.  */
+	    if (num_chars > 1
+		|| (num_chars == 1 && token_buffer[1] != '\0'))
+	      {
+		wchar_t wc;
+		(void) mbtowc (NULL_PTR, NULL_PTR, 0);
+		if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
+		  result = wc;
+		else
+		  warning ("Ignoring invalid multibyte character");
+	      }
+#endif
+	    yylval.ttype = build_int_2 (result, 0);
+	    TREE_TYPE (yylval.ttype) = wchar_type_node;
+	  }
+
+	value = CONSTANT;
+	break;
+      }
+
+    case '"':
+    string_constant:
+      {
+	c = getc (finput);
+	p = token_buffer + 1;
+
+	while (c != '"' && c >= 0)
+	  {
+	    /* ignore_escape_flag is set for reading the filename in #line.  */
+	    if (!ignore_escape_flag && c == '\\')
+	      {
+		int ignore = 0;
+		c = readescape (&ignore);
+		if (ignore)
+		  goto skipnewline;
+		if (!wide_flag
+		    && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
+		    && c >= (1 << TYPE_PRECISION (char_type_node)))
+		  pedwarn ("escape sequence out of range for character");
+	      }
+	    else if (c == '\n')
+	      {
+		if (pedantic)
+		  pedwarn ("ANSI C forbids newline in string constant");
+		lineno++;
+	      }
+
+	    if (p == token_buffer + maxtoken)
+	      p = extend_token_buffer (p);
+	    *p++ = c;
+
+	  skipnewline:
+	    c = getc (finput);
+	  }
+	*p = 0;
+
+	/* We have read the entire constant.
+	   Construct a STRING_CST for the result.  */
+
+	if (wide_flag)
+	  {
+	    /* If this is a L"..." wide-string, convert the multibyte string
+	       to a wide character string.  */
+	    char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
+	    int len;
+
+#ifdef MULTIBYTE_CHARS
+	    len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
+	    if (len < 0 || len >= (p - token_buffer))
+	      {
+		warning ("Ignoring invalid multibyte string");
+		len = 0;
+	      }
+	    bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
+#else
+	    {
+	      union { long l; char c[sizeof (long)]; } u;
+	      int big_endian;
+	      char *wp, *cp;
+
+	      /* Determine whether host is little or big endian.  */
+	      u.l = 1;
+	      big_endian = u.c[sizeof (long) - 1];
+	      wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
+
+	      bzero (widep, (p - token_buffer) * WCHAR_BYTES);
+	      for (cp = token_buffer + 1; cp < p; cp++)
+		*wp = *cp, wp += WCHAR_BYTES;
+	      len = p - token_buffer - 1;
+	    }
+#endif
+	    yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
+	    TREE_TYPE (yylval.ttype) = wchar_array_type_node;
+	    value = STRING;
+	  }
+	else if (objc_flag)
+	  {
+	    extern tree build_objc_string();
+	    /* Return an Objective-C @"..." constant string object.  */
+	    yylval.ttype = build_objc_string (p - token_buffer,
+					      token_buffer + 1);
+	    TREE_TYPE (yylval.ttype) = char_array_type_node;
+	    value = OBJC_STRING;
+	  }
+	else
+	  {
+	    yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
+	    TREE_TYPE (yylval.ttype) = char_array_type_node;
+	    value = STRING;
+	  }
+
+	*p++ = '"';
+	*p = 0;
+
+	break;
+      }
+
+    case '+':
+    case '-':
+    case '&':
+    case '|':
+    case '<':
+    case '>':
+    case '*':
+    case '/':
+    case '%':
+    case '^':
+    case '!':
+    case '=':
+      {
+	register int c1;
+
+      combine:
+
+	switch (c)
+	  {
+	  case '+':
+	    yylval.code = PLUS_EXPR; break;
+	  case '-':
+	    yylval.code = MINUS_EXPR; break;
+	  case '&':
+	    yylval.code = BIT_AND_EXPR; break;
+	  case '|':
+	    yylval.code = BIT_IOR_EXPR; break;
+	  case '*':
+	    yylval.code = MULT_EXPR; break;
+	  case '/':
+	    yylval.code = TRUNC_DIV_EXPR; break;
+	  case '%':
+	    yylval.code = TRUNC_MOD_EXPR; break;
+	  case '^':
+	    yylval.code = BIT_XOR_EXPR; break;
+	  case LSHIFT:
+	    yylval.code = LSHIFT_EXPR; break;
+	  case RSHIFT:
+	    yylval.code = RSHIFT_EXPR; break;
+	  case '<':
+	    yylval.code = LT_EXPR; break;
+	  case '>':
+	    yylval.code = GT_EXPR; break;
+	  }
+
+	token_buffer[1] = c1 = getc (finput);
+	token_buffer[2] = 0;
+
+	if (c1 == '=')
+	  {
+	    switch (c)
+	      {
+	      case '<':
+		value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
+	      case '>':
+		value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
+	      case '!':
+		value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
+	      case '=':
+		value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
+	      }
+	    value = ASSIGN; goto done;
+	  }
+	else if (c == c1)
+	  switch (c)
+	    {
+	    case '+':
+	      value = PLUSPLUS; goto done;
+	    case '-':
+	      value = MINUSMINUS; goto done;
+	    case '&':
+	      value = ANDAND; goto done;
+	    case '|':
+	      value = OROR; goto done;
+	    case '<':
+	      c = LSHIFT;
+	      goto combine;
+	    case '>':
+	      c = RSHIFT;
+	      goto combine;
+	    }
+	else if ((c == '-') && (c1 == '>'))
+	  { value = POINTSAT; goto done; }
+	ungetc (c1, finput);
+	token_buffer[1] = 0;
+
+	if ((c == '<') || (c == '>'))
+	  value = ARITHCOMPARE;
+	else value = c;
+	goto done;
+      }
+
+    case 0:
+      /* Don't make yyparse think this is eof.  */
+      value = 1;
+      break;
+
+    default:
+      value = c;
+    }
+
+done:
+/*  yylloc.last_line = lineno; */
+
+  return value;
+}
+
+/* Sets the value of the 'yydebug' variable to VALUE.
+   This is a function so we don't have to have YYDEBUG defined
+   in order to build the compiler.  */
+
+void
+set_yydebug (value)
+     int value;
+{
+#if YYDEBUG != 0
+  yydebug = value;
+#else
+  warning ("YYDEBUG not defined.");
+#endif
+}
diff --git a/gnu/usr.bin/cc/cc1/c-parse.c b/gnu/usr.bin/cc/cc1/c-parse.c
new file mode 100644
index 000000000000..fb86c886faf7
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-parse.c
@@ -0,0 +1,3435 @@
+
+/*  A Bison parser, made from c-parse.y  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define	IDENTIFIER	258
+#define	TYPENAME	259
+#define	SCSPEC	260
+#define	TYPESPEC	261
+#define	TYPE_QUAL	262
+#define	CONSTANT	263
+#define	STRING	264
+#define	ELLIPSIS	265
+#define	SIZEOF	266
+#define	ENUM	267
+#define	STRUCT	268
+#define	UNION	269
+#define	IF	270
+#define	ELSE	271
+#define	WHILE	272
+#define	DO	273
+#define	FOR	274
+#define	SWITCH	275
+#define	CASE	276
+#define	DEFAULT	277
+#define	BREAK	278
+#define	CONTINUE	279
+#define	RETURN	280
+#define	GOTO	281
+#define	ASM_KEYWORD	282
+#define	TYPEOF	283
+#define	ALIGNOF	284
+#define	ALIGN	285
+#define	ATTRIBUTE	286
+#define	EXTENSION	287
+#define	LABEL	288
+#define	REALPART	289
+#define	IMAGPART	290
+#define	ASSIGN	291
+#define	OROR	292
+#define	ANDAND	293
+#define	EQCOMPARE	294
+#define	ARITHCOMPARE	295
+#define	LSHIFT	296
+#define	RSHIFT	297
+#define	UNARY	298
+#define	PLUSPLUS	299
+#define	MINUSMINUS	300
+#define	HYPERUNARY	301
+#define	POINTSAT	302
+#define	INTERFACE	303
+#define	IMPLEMENTATION	304
+#define	END	305
+#define	SELECTOR	306
+#define	DEFS	307
+#define	ENCODE	308
+#define	CLASSNAME	309
+#define	PUBLIC	310
+#define	PRIVATE	311
+#define	PROTECTED	312
+#define	PROTOCOL	313
+#define	OBJECTNAME	314
+#define	CLASS	315
+#define	ALIAS	316
+#define	OBJC_STRING	317
+
+#line 44 "c-parse.y"
+
+#include <stdio.h>
+#include <errno.h>
+#include <setjmp.h>
+
+#include "config.h"
+#include "tree.h"
+#include "input.h"
+#include "c-lex.h"
+#include "c-tree.h"
+#include "flags.h"
+
+#ifdef MULTIBYTE_CHARS
+#include <stdlib.h>
+#include <locale.h>
+#endif
+
+
+/* Since parsers are distinct for each language, put the language string
+   definition here.  */
+char *language_string = "GNU C";
+
+#ifndef errno
+extern int errno;
+#endif
+
+void yyerror ();
+
+/* Like YYERROR but do call yyerror.  */
+#define YYERROR1 { yyerror ("syntax error"); YYERROR; }
+
+/* Cause the `yydebug' variable to be defined.  */
+#define YYDEBUG 1
+
+#line 81 "c-parse.y"
+typedef union {long itype; tree ttype; enum tree_code code;
+	char *filename; int lineno; } YYSTYPE;
+#line 192 "c-parse.y"
+
+/* Number of statements (loosely speaking) seen so far.  */
+static int stmt_count;
+
+/* Input file and line number of the end of the body of last simple_if;
+   used by the stmt-rule immediately after simple_if returns.  */
+static char *if_stmt_file;
+static int if_stmt_line;
+
+/* List of types and structure classes of the current declaration.  */
+static tree current_declspecs;
+
+/* Stack of saved values of current_declspecs.  */
+static tree declspec_stack;
+
+/* 1 if we explained undeclared var errors.  */
+static int undeclared_variable_notice;
+
+
+/* Tell yyparse how to print a token's value, if yydebug is set.  */
+
+#define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL)
+extern void yyprint ();
+
+#ifndef YYLTYPE
+typedef
+  struct yyltype
+    {
+      int timestamp;
+      int first_line;
+      int first_column;
+      int last_line;
+      int last_column;
+      char *text;
+   }
+  yyltype;
+
+#define YYLTYPE yyltype
+#endif
+
+#include <stdio.h>
+
+#ifndef __STDC__
+#define const
+#endif
+
+
+
+#define	YYFINAL		613
+#define	YYFLAG		-32768
+#define	YYNTBASE	85
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 317 ? yytranslate[x] : 212)
+
+static const char yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    81,     2,     2,     2,    53,    44,     2,    60,
+    77,    51,    49,    82,    50,    59,    52,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,    39,    78,     2,
+    37,     2,    38,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+    61,     2,    84,    43,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,    83,    42,    79,    80,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
+     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+    36,    40,    41,    45,    46,    47,    48,    54,    55,    56,
+    57,    58,    62,    63,    64,    65,    66,    67,    68,    69,
+    70,    71,    72,    73,    74,    75,    76
+};
+
+static const short yyprhs[] = {     0,
+     0,     1,     3,     4,     7,     8,    12,    14,    16,    22,
+    26,    31,    36,    39,    42,    45,    48,    50,    51,    52,
+    60,    65,    66,    67,    75,    80,    81,    82,    89,    93,
+    95,    97,    99,   101,   103,   105,   107,   109,   111,   113,
+   114,   116,   118,   122,   124,   127,   128,   132,   135,   138,
+   141,   146,   149,   154,   157,   160,   162,   167,   175,   177,
+   181,   185,   189,   193,   197,   201,   205,   209,   213,   217,
+   221,   225,   229,   233,   239,   243,   247,   249,   251,   253,
+   257,   261,   262,   267,   272,   277,   281,   285,   288,   291,
+   293,   296,   297,   299,   302,   306,   308,   310,   313,   316,
+   321,   326,   329,   332,   336,   338,   340,   343,   346,   347,
+   352,   357,   361,   365,   368,   371,   374,   378,   379,   382,
+   385,   387,   389,   392,   395,   398,   402,   403,   406,   408,
+   410,   412,   417,   422,   424,   426,   428,   430,   434,   436,
+   440,   441,   446,   447,   454,   458,   459,   466,   470,   471,
+   478,   480,   484,   486,   491,   496,   505,   507,   510,   514,
+   519,   521,   523,   527,   534,   543,   548,   555,   559,   565,
+   566,   570,   571,   575,   577,   579,   583,   587,   592,   596,
+   600,   602,   606,   611,   615,   619,   621,   625,   629,   633,
+   638,   642,   644,   645,   652,   657,   660,   661,   668,   673,
+   676,   677,   685,   686,   693,   696,   697,   699,   700,   702,
+   704,   707,   708,   712,   715,   719,   721,   725,   727,   729,
+   731,   735,   740,   747,   753,   755,   759,   761,   765,   768,
+   771,   772,   774,   776,   779,   780,   783,   787,   791,   794,
+   798,   803,   807,   810,   814,   817,   819,   822,   825,   826,
+   828,   831,   832,   833,   835,   837,   840,   844,   846,   849,
+   852,   859,   865,   871,   874,   877,   882,   883,   888,   889,
+   890,   894,   899,   903,   905,   907,   909,   911,   914,   915,
+   920,   922,   926,   927,   928,   936,   942,   945,   946,   947,
+   948,   961,   962,   969,   972,   975,   978,   982,   989,   998,
+  1009,  1022,  1026,  1031,  1033,  1035,  1036,  1043,  1047,  1053,
+  1056,  1059,  1060,  1062,  1063,  1065,  1066,  1068,  1070,  1074,
+  1079,  1081,  1085,  1086,  1089,  1092,  1093,  1098,  1101,  1102,
+  1104,  1106,  1110,  1112,  1116,  1119,  1122,  1125,  1128,  1131,
+  1132,  1135,  1137,  1140,  1142,  1146,  1148
+};
+
+static const short yyrhs[] = {    -1,
+    86,     0,     0,    87,    89,     0,     0,    86,    88,    89,
+     0,    91,     0,    90,     0,    27,    60,   100,    77,    78,
+     0,   116,   126,    78,     0,   120,   116,   126,    78,     0,
+   118,   116,   125,    78,     0,   120,    78,     0,   118,    78,
+     0,     1,    78,     0,     1,    79,     0,    78,     0,     0,
+     0,   118,   116,   141,    92,   110,    93,   171,     0,   118,
+   116,   141,     1,     0,     0,     0,   120,   116,   144,    94,
+   110,    95,   171,     0,   120,   116,   144,     1,     0,     0,
+     0,   116,   144,    96,   110,    97,   171,     0,   116,   144,
+     1,     0,     3,     0,     4,     0,    44,     0,    50,     0,
+    49,     0,    55,     0,    56,     0,    80,     0,    81,     0,
+   102,     0,     0,   102,     0,   106,     0,   102,    82,   106,
+     0,   107,     0,    51,   105,     0,     0,    32,   104,   105,
+     0,    99,   105,     0,    41,    98,     0,    11,   103,     0,
+    11,    60,   159,    77,     0,    29,   103,     0,    29,    60,
+   159,    77,     0,    34,   105,     0,    35,   105,     0,   103,
+     0,    60,   159,    77,   105,     0,    60,   159,    77,    83,
+   136,   150,    79,     0,   105,     0,   106,    49,   106,     0,
+   106,    50,   106,     0,   106,    51,   106,     0,   106,    52,
+   106,     0,   106,    53,   106,     0,   106,    47,   106,     0,
+   106,    48,   106,     0,   106,    46,   106,     0,   106,    45,
+   106,     0,   106,    44,   106,     0,   106,    42,   106,     0,
+   106,    43,   106,     0,   106,    41,   106,     0,   106,    40,
+   106,     0,   106,    38,   195,    39,   106,     0,   106,    37,
+   106,     0,   106,    36,   106,     0,     3,     0,     8,     0,
+   109,     0,    60,   100,    77,     0,    60,     1,    77,     0,
+     0,    60,   108,   172,    77,     0,   107,    60,   101,    77,
+     0,   107,    61,   100,    84,     0,   107,    59,    98,     0,
+   107,    58,    98,     0,   107,    55,     0,   107,    56,     0,
+     9,     0,   109,     9,     0,     0,   112,     0,   112,    10,
+     0,   177,   178,   113,     0,   111,     0,   166,     0,   112,
+   111,     0,   111,   166,     0,   118,   116,   125,    78,     0,
+   120,   116,   126,    78,     0,   118,    78,     0,   120,    78,
+     0,   177,   178,   117,     0,   114,     0,   166,     0,   115,
+   114,     0,   114,   166,     0,     0,   118,   116,   125,    78,
+     0,   120,   116,   126,    78,     0,   118,   116,   137,     0,
+   120,   116,   139,     0,   118,    78,     0,   120,    78,     0,
+   123,   119,     0,   120,   123,   119,     0,     0,   119,   124,
+     0,   119,     5,     0,     7,     0,     5,     0,   120,     7,
+     0,   120,     5,     0,   123,   122,     0,   161,   123,   122,
+     0,     0,   122,   124,     0,     6,     0,   145,     0,     4,
+     0,    28,    60,   100,    77,     0,    28,    60,   159,    77,
+     0,     6,     0,     7,     0,   145,     0,   128,     0,   125,
+    82,   128,     0,   130,     0,   126,    82,   128,     0,     0,
+    27,    60,   109,    77,     0,     0,   141,   127,   132,    37,
+   129,   135,     0,   141,   127,   132,     0,     0,   144,   127,
+   132,    37,   131,   135,     0,   144,   127,   132,     0,     0,
+    31,    60,    60,   133,    77,    77,     0,   134,     0,   133,
+    82,   134,     0,     3,     0,     3,    60,     3,    77,     0,
+     3,    60,     8,    77,     0,     3,    60,     3,    82,     8,
+    82,     8,    77,     0,   106,     0,    83,    79,     0,    83,
+   136,    79,     0,    83,   136,    82,    79,     0,     1,     0,
+   135,     0,   136,    82,   135,     0,    61,   106,    10,   106,
+    84,   135,     0,   136,    82,    61,   106,    10,   106,    84,
+   135,     0,    61,   106,    84,   135,     0,   136,    82,    61,
+   106,    84,   135,     0,    98,    39,   135,     0,   136,    82,
+    98,    39,   135,     0,     0,   141,   138,   172,     0,     0,
+   144,   140,   172,     0,   142,     0,   144,     0,    60,   142,
+    77,     0,   142,    60,   207,     0,   142,    61,   100,    84,
+     0,   142,    61,    84,     0,    51,   162,   142,     0,     4,
+     0,   143,    60,   207,     0,   143,    61,   100,    84,     0,
+   143,    61,    84,     0,    51,   162,   143,     0,     4,     0,
+   144,    60,   207,     0,    60,   144,    77,     0,    51,   162,
+   144,     0,   144,    61,   100,    84,     0,   144,    61,    84,
+     0,     3,     0,     0,    13,    98,    83,   146,   152,    79,
+     0,    13,    83,   152,    79,     0,    13,    98,     0,     0,
+    14,    98,    83,   147,   152,    79,     0,    14,    83,   152,
+    79,     0,    14,    98,     0,     0,    12,    98,    83,   148,
+   157,   151,    79,     0,     0,    12,    83,   149,   157,   151,
+    79,     0,    12,    98,     0,     0,    82,     0,     0,    82,
+     0,   153,     0,   153,   154,     0,     0,   153,   154,    78,
+     0,   153,    78,     0,   121,   116,   155,     0,   121,     0,
+   161,   116,   155,     0,   161,     0,     1,     0,   156,     0,
+   155,    82,   156,     0,   177,   178,   141,   132,     0,   177,
+   178,   141,    39,   106,   132,     0,   177,   178,    39,   106,
+   132,     0,   158,     0,   157,    82,   158,     0,    98,     0,
+    98,    37,   106,     0,   121,   160,     0,   161,   160,     0,
+     0,   163,     0,     7,     0,   161,     7,     0,     0,   162,
+     7,     0,    60,   163,    77,     0,    51,   162,   163,     0,
+    51,   162,     0,   163,    60,   200,     0,   163,    61,   100,
+    84,     0,   163,    61,    84,     0,    60,   200,     0,    61,
+   100,    84,     0,    61,    84,     0,   180,     0,   164,   180,
+     0,   164,   166,     0,     0,   164,     0,     1,    78,     0,
+     0,     0,   169,     0,   170,     0,   169,   170,     0,    33,
+   211,    78,     0,   172,     0,     1,   172,     0,    83,    79,
+     0,    83,   167,   168,   115,   165,    79,     0,    83,   167,
+   168,     1,    79,     0,    83,   167,   168,   164,    79,     0,
+   174,   179,     0,   174,     1,     0,    15,    60,   100,    77,
+     0,     0,    18,   176,   179,    17,     0,     0,     0,   177,
+   178,   182,     0,   177,   178,   193,   179,     0,   177,   178,
+   181,     0,   182,     0,   193,     0,   172,     0,   190,     0,
+   100,    78,     0,     0,   173,    16,   183,   179,     0,   173,
+     0,   173,    16,     1,     0,     0,     0,    17,   184,    60,
+   100,    77,   185,   179,     0,   175,    60,   100,    77,    78,
+     0,   175,     1,     0,     0,     0,     0,    19,    60,   195,
+    78,   186,   195,    78,   187,   195,    77,   188,   179,     0,
+     0,    20,    60,   100,    77,   189,   179,     0,    23,    78,
+     0,    24,    78,     0,    25,    78,     0,    25,   100,    78,
+     0,    27,   194,    60,   100,    77,    78,     0,    27,   194,
+    60,   100,    39,   196,    77,    78,     0,    27,   194,    60,
+   100,    39,   196,    39,   196,    77,    78,     0,    27,   194,
+    60,   100,    39,   196,    39,   196,    39,   199,    77,    78,
+     0,    26,    98,    78,     0,    26,    51,   100,    78,     0,
+    78,     0,   191,     0,     0,    19,    60,   107,    77,   192,
+   179,     0,    21,   106,    39,     0,    21,   106,    10,   106,
+    39,     0,    22,    39,     0,    98,    39,     0,     0,     7,
+     0,     0,   100,     0,     0,   197,     0,   198,     0,   197,
+    82,   198,     0,     9,    60,   100,    77,     0,   109,     0,
+   199,    82,   109,     0,     0,   201,   202,     0,   204,    77,
+     0,     0,   205,    78,   203,   202,     0,     1,    77,     0,
+     0,    10,     0,   205,     0,   205,    82,    10,     0,   206,
+     0,   205,    82,   206,     0,   118,   143,     0,   118,   144,
+     0,   118,   160,     0,   120,   144,     0,   120,   160,     0,
+     0,   208,   209,     0,   202,     0,   210,    77,     0,     3,
+     0,   210,    82,     3,     0,    98,     0,   211,    82,    98,
+     0
+};
+
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+   218,   222,   235,   237,   237,   238,   240,   242,   243,   253,
+   259,   261,   263,   265,   267,   268,   269,   274,   280,   282,
+   283,   285,   290,   292,   293,   295,   300,   302,   303,   307,
+   309,   312,   314,   316,   318,   320,   322,   324,   328,   332,
+   335,   338,   341,   345,   347,   350,   353,   356,   360,   386,
+   391,   393,   395,   397,   399,   403,   405,   408,   433,   435,
+   437,   439,   441,   443,   445,   447,   449,   451,   453,   455,
+   457,   459,   461,   463,   465,   468,   474,   575,   576,   578,
+   584,   586,   600,   618,   620,   622,   626,   632,   634,   639,
+   641,   646,   648,   649,   659,   664,   666,   667,   668,   671,
+   676,   680,   683,   691,   696,   698,   699,   700,   707,   715,
+   720,   724,   728,   732,   734,   742,   745,   749,   751,   753,
+   764,   768,   770,   773,   786,   789,   793,   795,   803,   804,
+   805,   809,   811,   817,   818,   819,   822,   824,   827,   829,
+   832,   835,   841,   846,   848,   854,   859,   861,   868,   871,
+   876,   878,   883,   888,   898,   909,   927,   929,   933,   935,
+   937,   943,   946,   951,   955,   960,   962,   964,   966,   970,
+   987,   991,  1008,  1015,  1017,  1022,  1025,  1030,  1032,  1034,
+  1036,  1044,  1050,  1052,  1054,  1056,  1062,  1068,  1070,  1072,
+  1074,  1076,  1079,  1084,  1088,  1091,  1093,  1095,  1097,  1100,
+  1102,  1105,  1108,  1111,  1114,  1118,  1120,  1123,  1125,  1129,
+  1132,  1137,  1139,  1141,  1155,  1161,  1166,  1171,  1176,  1180,
+  1182,  1186,  1190,  1194,  1204,  1206,  1211,  1214,  1218,  1221,
+  1225,  1228,  1231,  1234,  1238,  1241,  1245,  1249,  1251,  1253,
+  1255,  1257,  1259,  1261,  1263,  1271,  1273,  1274,  1277,  1279,
+  1282,  1285,  1296,  1298,  1303,  1305,  1308,  1322,  1325,  1328,
+  1330,  1335,  1340,  1348,  1353,  1356,  1369,  1377,  1381,  1385,
+  1389,  1395,  1399,  1404,  1406,  1417,  1420,  1421,  1426,  1431,
+  1434,  1442,  1444,  1454,  1464,  1465,  1473,  1476,  1488,  1492,
+  1509,  1516,  1525,  1527,  1532,  1537,  1541,  1545,  1556,  1563,
+  1570,  1577,  1588,  1592,  1595,  1600,  1623,  1654,  1678,  1706,
+  1721,  1732,  1735,  1739,  1742,  1747,  1749,  1752,  1754,  1758,
+  1763,  1766,  1772,  1777,  1782,  1784,  1793,  1794,  1800,  1802,
+  1807,  1809,  1813,  1816,  1822,  1825,  1827,  1829,  1831,  1838,
+  1843,  1848,  1850,  1859,  1862,  1867,  1870
+};
+
+static const char * const yytname[] = {   "$","error","$illegal.","IDENTIFIER",
+"TYPENAME","SCSPEC","TYPESPEC","TYPE_QUAL","CONSTANT","STRING","ELLIPSIS","SIZEOF",
+"ENUM","STRUCT","UNION","IF","ELSE","WHILE","DO","FOR","SWITCH","CASE","DEFAULT",
+"BREAK","CONTINUE","RETURN","GOTO","ASM_KEYWORD","TYPEOF","ALIGNOF","ALIGN",
+"ATTRIBUTE","EXTENSION","LABEL","REALPART","IMAGPART","ASSIGN","'='","'?'","':'",
+"OROR","ANDAND","'|'","'^'","'&'","EQCOMPARE","ARITHCOMPARE","LSHIFT","RSHIFT",
+"'+'","'-'","'*'","'/'","'%'","UNARY","PLUSPLUS","MINUSMINUS","HYPERUNARY","POINTSAT",
+"'.'","'('","'['","INTERFACE","IMPLEMENTATION","END","SELECTOR","DEFS","ENCODE",
+"CLASSNAME","PUBLIC","PRIVATE","PROTECTED","PROTOCOL","OBJECTNAME","CLASS","ALIAS",
+"OBJC_STRING","')'","';'","'}'","'~'","'!'","','","'{'","']'","program","extdefs",
+"@1","@2","extdef","datadef","fndef","@3","@4","@5","@6","@7","@8","identifier",
+"unop","expr","exprlist","nonnull_exprlist","unary_expr","@9","cast_expr","expr_no_commas",
+"primary","@10","string","xdecls","lineno_datadecl","datadecls","datadecl","lineno_decl",
+"decls","setspecs","decl","typed_declspecs","reserved_declspecs","declmods",
+"typed_typespecs","reserved_typespecquals","typespec","typespecqual_reserved",
+"initdecls","notype_initdecls","maybeasm","initdcl","@11","notype_initdcl","@12",
+"maybe_attribute","attribute_list","attrib","init","initlist","nested_function",
+"@13","notype_nested_function","@14","declarator","after_type_declarator","parm_declarator",
+"notype_declarator","structsp","@15","@16","@17","@18","maybecomma","maybecomma_warn",
+"component_decl_list","component_decl_list2","component_decl","components","component_declarator",
+"enumlist","enumerator","typename","absdcl","nonempty_type_quals","type_quals",
+"absdcl1","stmts","xstmts","errstmt","pushlevel","maybe_label_decls","label_decls",
+"label_decl","compstmt_or_error","compstmt","simple_if","if_prefix","do_stmt_start",
+"@19","save_filename","save_lineno","lineno_labeled_stmt","lineno_stmt_or_label",
+"stmt_or_label","stmt","@20","@21","@22","@23","@24","@25","@26","all_iter_stmt",
+"all_iter_stmt_simple","@27","label","maybe_type_qual","xexpr","asm_operands",
+"nonnull_asm_operands","asm_operand","asm_clobbers","parmlist","@28","parmlist_1",
+"@29","parmlist_2","parms","parm","parmlist_or_identifiers","@30","parmlist_or_identifiers_1",
+"identifiers","identifiers_or_typenames",""
+};
+#endif
+
+static const short yyr1[] = {     0,
+    85,    85,    87,    86,    88,    86,    89,    89,    89,    90,
+    90,    90,    90,    90,    90,    90,    90,    92,    93,    91,
+    91,    94,    95,    91,    91,    96,    97,    91,    91,    98,
+    98,    99,    99,    99,    99,    99,    99,    99,   100,   101,
+   101,   102,   102,   103,   103,   104,   103,   103,   103,   103,
+   103,   103,   103,   103,   103,   105,   105,   105,   106,   106,
+   106,   106,   106,   106,   106,   106,   106,   106,   106,   106,
+   106,   106,   106,   106,   106,   106,   107,   107,   107,   107,
+   107,   108,   107,   107,   107,   107,   107,   107,   107,   109,
+   109,   110,   110,   110,   111,   112,   112,   112,   112,   113,
+   113,   113,   113,   114,   115,   115,   115,   115,   116,   117,
+   117,   117,   117,   117,   117,   118,   118,   119,   119,   119,
+   120,   120,   120,   120,   121,   121,   122,   122,   123,   123,
+   123,   123,   123,   124,   124,   124,   125,   125,   126,   126,
+   127,   127,   129,   128,   128,   131,   130,   130,   132,   132,
+   133,   133,   134,   134,   134,   134,   135,   135,   135,   135,
+   135,   136,   136,   136,   136,   136,   136,   136,   136,   138,
+   137,   140,   139,   141,   141,   142,   142,   142,   142,   142,
+   142,   143,   143,   143,   143,   143,   144,   144,   144,   144,
+   144,   144,   146,   145,   145,   145,   147,   145,   145,   145,
+   148,   145,   149,   145,   145,   150,   150,   151,   151,   152,
+   152,   153,   153,   153,   154,   154,   154,   154,   154,   155,
+   155,   156,   156,   156,   157,   157,   158,   158,   159,   159,
+   160,   160,   161,   161,   162,   162,   163,   163,   163,   163,
+   163,   163,   163,   163,   163,   164,   164,   164,   165,   165,
+   166,   167,   168,   168,   169,   169,   170,   171,   171,   172,
+   172,   172,   172,   173,   173,   174,   176,   175,   177,   178,
+   179,   179,   180,   181,   181,   182,   182,   182,   183,   182,
+   182,   182,   184,   185,   182,   182,   182,   186,   187,   188,
+   182,   189,   182,   182,   182,   182,   182,   182,   182,   182,
+   182,   182,   182,   182,   190,   192,   191,   193,   193,   193,
+   193,   194,   194,   195,   195,   196,   196,   197,   197,   198,
+   199,   199,   201,   200,   202,   203,   202,   202,   204,   204,
+   204,   204,   205,   205,   206,   206,   206,   206,   206,   208,
+   207,   209,   209,   210,   210,   211,   211
+};
+
+static const short yyr2[] = {     0,
+     0,     1,     0,     2,     0,     3,     1,     1,     5,     3,
+     4,     4,     2,     2,     2,     2,     1,     0,     0,     7,
+     4,     0,     0,     7,     4,     0,     0,     6,     3,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
+     1,     1,     3,     1,     2,     0,     3,     2,     2,     2,
+     4,     2,     4,     2,     2,     1,     4,     7,     1,     3,
+     3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+     3,     3,     3,     5,     3,     3,     1,     1,     1,     3,
+     3,     0,     4,     4,     4,     3,     3,     2,     2,     1,
+     2,     0,     1,     2,     3,     1,     1,     2,     2,     4,
+     4,     2,     2,     3,     1,     1,     2,     2,     0,     4,
+     4,     3,     3,     2,     2,     2,     3,     0,     2,     2,
+     1,     1,     2,     2,     2,     3,     0,     2,     1,     1,
+     1,     4,     4,     1,     1,     1,     1,     3,     1,     3,
+     0,     4,     0,     6,     3,     0,     6,     3,     0,     6,
+     1,     3,     1,     4,     4,     8,     1,     2,     3,     4,
+     1,     1,     3,     6,     8,     4,     6,     3,     5,     0,
+     3,     0,     3,     1,     1,     3,     3,     4,     3,     3,
+     1,     3,     4,     3,     3,     1,     3,     3,     3,     4,
+     3,     1,     0,     6,     4,     2,     0,     6,     4,     2,
+     0,     7,     0,     6,     2,     0,     1,     0,     1,     1,
+     2,     0,     3,     2,     3,     1,     3,     1,     1,     1,
+     3,     4,     6,     5,     1,     3,     1,     3,     2,     2,
+     0,     1,     1,     2,     0,     2,     3,     3,     2,     3,
+     4,     3,     2,     3,     2,     1,     2,     2,     0,     1,
+     2,     0,     0,     1,     1,     2,     3,     1,     2,     2,
+     6,     5,     5,     2,     2,     4,     0,     4,     0,     0,
+     3,     4,     3,     1,     1,     1,     1,     2,     0,     4,
+     1,     3,     0,     0,     7,     5,     2,     0,     0,     0,
+    12,     0,     6,     2,     2,     2,     3,     6,     8,    10,
+    12,     3,     4,     1,     1,     0,     6,     3,     5,     2,
+     2,     0,     1,     0,     1,     0,     1,     1,     3,     4,
+     1,     3,     0,     2,     2,     0,     4,     2,     0,     1,
+     1,     3,     1,     3,     2,     2,     2,     2,     2,     0,
+     2,     1,     2,     1,     3,     1,     3
+};
+
+static const short yydefact[] = {     3,
+     5,     0,     0,     0,   131,   122,   129,   121,     0,     0,
+     0,     0,     0,    17,     4,     8,     7,     0,   109,   109,
+   118,   130,     6,    15,    16,    30,    31,   203,   205,   212,
+   196,   212,   200,     0,     0,   192,   235,     0,     0,   139,
+     0,    14,     0,   124,   123,    13,     0,   118,   116,     0,
+   201,     0,     0,   193,     0,   197,    77,    78,    90,     0,
+     0,    46,     0,     0,     0,    32,    34,    33,     0,    35,
+    36,     0,    37,    38,     0,     0,    39,    56,    59,    42,
+    44,    79,   233,     0,   231,   127,     0,   231,     0,     0,
+    10,     0,    29,     0,   340,     0,     0,   149,   181,   235,
+     0,     0,   137,     0,   174,   175,     0,     0,   117,   120,
+   134,   135,   119,   136,   227,   208,   225,     0,   195,   219,
+   214,   109,   211,   109,   212,   199,   212,     0,    50,     0,
+    52,     0,    54,    55,    49,    45,     0,     0,     0,     0,
+    48,     0,     0,     0,     0,   314,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    88,    89,     0,     0,    40,     0,    91,   132,   235,   323,
+     0,   229,   232,   125,   133,   234,   127,   230,   236,   189,
+   188,   140,   141,     0,   187,     0,   191,     0,     0,    27,
+     0,   269,    97,   270,     0,   148,     0,     0,    12,     0,
+    21,     0,   149,   340,     0,    11,    25,     0,     0,   209,
+     0,   208,   269,   213,   269,     0,     0,     0,     0,    47,
+    81,    80,   252,     0,     0,     9,    43,    76,    75,   315,
+     0,    73,    72,    70,    71,    69,    68,    67,    65,    66,
+    60,    61,    62,    63,    64,    87,    86,     0,    41,     0,
+   239,     0,   243,     0,   245,     0,   323,     0,   128,   126,
+     0,     0,   344,   330,   231,   231,   342,     0,   331,   333,
+   341,     0,   190,   251,     0,    99,    94,    98,     0,     0,
+   146,   180,   176,   138,    19,   145,   177,   179,     0,    23,
+   228,   226,   204,     0,   215,   220,   270,   217,   194,   198,
+    51,    53,   260,   253,    83,     0,    57,     0,    84,    85,
+   238,   237,   324,   244,   240,   242,     0,   142,   328,   186,
+   235,   323,   335,   336,   337,   235,   338,   339,   325,   326,
+     0,   343,     0,     0,    28,   258,    95,   109,   109,     0,
+     0,     0,   143,   178,     0,   202,   269,     0,     0,     0,
+   254,   255,   161,    77,     0,     0,     0,   157,   162,   206,
+    74,   241,   239,   340,     0,   239,     0,   332,   334,   345,
+   259,   102,     0,   103,     0,   153,     0,   151,   147,    20,
+     0,    24,   221,     0,   149,   346,     0,     0,     0,   269,
+     0,   106,   270,   246,   256,     0,   158,     0,     0,     0,
+     0,   185,   182,   184,     0,   327,     0,     0,   141,     0,
+     0,     0,   144,   149,     0,   222,   257,     0,   262,   108,
+   107,     0,     0,   263,   248,   270,   247,     0,     0,     0,
+   159,     0,   168,     0,     0,   163,    58,   183,   100,   101,
+     0,     0,   150,   152,   224,   149,   347,   261,     0,   131,
+     0,   283,   267,     0,     0,     0,     0,     0,     0,     0,
+     0,   312,   304,     0,     0,   104,   109,   109,   276,   281,
+     0,     0,   273,   274,   277,   305,   275,     0,   166,   160,
+     0,     0,   154,     0,   155,   223,     0,     0,   269,   314,
+     0,     0,   310,   294,   295,   296,     0,     0,     0,   313,
+     0,   311,   278,   114,     0,   115,     0,     0,   265,   270,
+   264,   287,     0,     0,     0,     0,   169,     0,     0,     0,
+     0,    44,     0,     0,     0,   308,   297,     0,   302,     0,
+     0,   112,   141,     0,   113,   141,   282,   269,     0,     0,
+   164,     0,   167,     0,   266,     0,   268,   306,   288,   292,
+     0,   303,     0,   110,     0,   111,     0,   280,   271,   269,
+     0,     0,     0,   284,   269,   314,   269,   309,   316,     0,
+   171,   173,   272,   286,   165,   156,   269,   307,     0,   293,
+     0,     0,   317,   318,   298,   285,   289,     0,   316,     0,
+     0,   314,     0,     0,   299,   319,     0,   320,     0,     0,
+   290,   321,     0,   300,   269,     0,     0,   291,   301,   322,
+     0,     0,     0
+};
+
+static const short yydefgoto[] = {   611,
+     1,     2,     3,    15,    16,    17,   202,   342,   208,   345,
+    97,   275,   115,    75,   230,   248,    77,    78,   132,    79,
+    80,    81,   139,    82,   190,   191,   192,   337,   389,   390,
+    18,   466,   265,    49,   266,    85,   174,    21,   113,   102,
+    39,    98,   103,   381,    40,   341,   196,   377,   378,   359,
+   360,   532,   555,   535,   557,   183,   105,   323,   106,    22,
+   125,   127,   118,    50,   401,   211,    52,    53,   123,   295,
+   296,   116,   117,    87,   172,    88,    89,   173,   391,   423,
+   193,   304,   350,   351,   352,   335,   336,   470,   471,   472,
+   489,   510,   279,   511,   394,   473,   474,   538,   488,   577,
+   566,   592,   605,   567,   475,   476,   565,   477,   501,   231,
+   582,   583,   584,   603,   253,   254,   267,   367,   268,   269,
+   270,   185,   186,   271,   272,   387
+};
+
+static const short yypact[] = {    49,
+    95,   710,   710,   262,-32768,-32768,-32768,-32768,    64,    66,
+    70,    60,    86,-32768,-32768,-32768,-32768,    33,   -36,   332,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    65,-32768,
+    79,-32768,   128,  1837,  1753,-32768,-32768,    33,    94,-32768,
+   391,-32768,   444,-32768,-32768,-32768,    33,-32768,   312,    68,
+-32768,   141,   154,-32768,   144,-32768,-32768,-32768,-32768,  1850,
+  1900,-32768,  1837,  1837,    68,-32768,-32768,-32768,  1837,-32768,
+-32768,  1032,-32768,-32768,  1837,   165,   169,-32768,-32768,  2059,
+   637,   247,-32768,   188,   187,-32768,   191,   951,   356,     0,
+-32768,   444,-32768,   211,-32768,  1379,   529,   245,-32768,-32768,
+   444,   153,-32768,   273,   297,   308,   176,   486,   312,-32768,
+-32768,-32768,-32768,-32768,   244,   202,-32768,    68,-32768,-32768,
+-32768,   311,   224,   215,-32768,-32768,-32768,  1032,-32768,  1032,
+-32768,  1837,-32768,-32768,-32768,-32768,   228,   231,   251,   243,
+-32768,   265,  1837,  1837,  1837,  1837,  1837,  1837,  1837,  1837,
+  1837,  1837,  1837,  1837,  1837,  1837,  1837,  1837,  1837,  1837,
+-32768,-32768,    68,    68,  1837,  1837,-32768,-32768,-32768,   187,
+  1392,-32768,   352,   538,-32768,-32768,-32768,-32768,-32768,   308,
+-32768,-32768,   321,   362,-32768,   632,-32768,   307,   322,-32768,
+   360,    42,-32768,-32768,   346,   377,   263,     4,-32768,   444,
+-32768,   529,   245,-32768,  1446,-32768,-32768,   529,  1837,    68,
+   341,   202,-32768,-32768,-32768,   344,   350,   354,   357,-32768,
+-32768,-32768,   376,   373,  1695,-32768,  2059,  2059,  2059,-32768,
+   400,  2072,  1299,  2083,  1875,  2092,  1485,   459,   432,   432,
+   328,   328,-32768,-32768,-32768,-32768,-32768,   383,   169,   379,
+   114,   109,-32768,   789,-32768,   393,-32768,  1459,-32768,   538,
+    24,   420,-32768,-32768,   222,   875,-32768,   424,   181,-32768,
+-32768,   101,-32768,-32768,    40,-32768,-32768,-32768,   926,   443,
+-32768,   297,-32768,-32768,-32768,   485,-32768,-32768,   442,-32768,
+  2059,-32768,-32768,   448,   447,-32768,-32768,   447,-32768,-32768,
+-32768,-32768,-32768,   498,-32768,  1273,-32768,  1837,-32768,-32768,
+   352,-32768,-32768,-32768,-32768,-32768,   454,-32768,-32768,-32768,
+-32768,   261,   411,   308,-32768,-32768,   308,-32768,-32768,-32768,
+  1104,-32768,   536,   251,-32768,-32768,-32768,   462,   371,   545,
+  1329,    40,-32768,-32768,    40,-32768,-32768,   405,    68,   650,
+   498,-32768,-32768,   510,  1837,  1090,   514,  2059,-32768,   473,
+  1669,-32768,   103,-32768,  1513,   237,   789,-32768,-32768,-32768,
+-32768,-32768,   444,-32768,    33,   496,   110,-32768,-32768,-32768,
+  1329,-32768,-32768,  1837,   111,-32768,   225,   410,   569,   479,
+   731,-32768,-32768,-32768,-32768,  1926,-32768,    26,  1329,  1151,
+   480,   411,-32768,-32768,   481,-32768,   250,   304,   235,   177,
+   489,   545,-32768,  2016,  1837,-32768,-32768,    68,-32768,-32768,
+-32768,   812,   484,-32768,-32768,-32768,-32768,  1595,  1837,  1329,
+-32768,  1212,-32768,  1837,   528,-32768,-32768,-32768,-32768,-32768,
+   157,   502,-32768,-32768,-32768,  2016,-32768,-32768,  1645,   546,
+   539,-32768,-32768,   540,   542,  1837,   566,   531,   533,  1787,
+    52,   599,-32768,   568,   537,-32768,   543,   845,-32768,   598,
+   893,    30,-32768,-32768,-32768,-32768,-32768,  1971,-32768,-32768,
+  1947,  1329,-32768,   608,-32768,-32768,  1837,   557,-32768,  1837,
+  1837,  1539,-32768,-32768,-32768,-32768,   544,  1837,   548,-32768,
+   563,-32768,-32768,-32768,   444,-32768,    33,   974,-32768,-32768,
+-32768,-32768,  1837,  1329,  1837,  1329,-32768,   549,   550,  1837,
+   611,   460,   552,   555,  1837,-32768,-32768,   556,-32768,  1837,
+   358,-32768,    21,   388,-32768,   230,-32768,-32768,  1645,   564,
+-32768,  1992,-32768,   635,-32768,   589,-32768,-32768,-32768,-32768,
+  2041,-32768,    15,-32768,   251,-32768,   251,-32768,-32768,-32768,
+   562,  1329,   603,-32768,-32768,  1837,-32768,-32768,   672,   605,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   609,-32768,
+   626,    20,   606,-32768,-32768,-32768,-32768,  1837,   672,   612,
+   672,  1837,   625,    39,-32768,-32768,   627,-32768,   362,   629,
+-32768,   247,   168,-32768,-32768,   630,   362,-32768,-32768,   247,
+   689,   703,-32768
+};
+
+static const short yypgoto[] = {-32768,
+-32768,-32768,-32768,   709,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,    -7,-32768,   -34,-32768,   553,   464,-32768,   -18,
+    46,   229,-32768,  -175,  -117,   534,-32768,-32768,   330,-32768,
+    -9,-32768,    10,   673,    13,   674,   559,    -6,  -124,  -346,
+   -40,   -96,   -55,-32768,-32768,-32768,  -177,-32768,   313,  -301,
+   385,-32768,-32768,-32768,-32768,   -37,   -62,   366,   -13,   -30,
+-32768,-32768,-32768,-32768,-32768,   532,     3,-32768,-32768,   530,
+   396,   641,   554,   -19,   -56,   694,   -80,  -149,   372,-32768,
+  -173,-32768,-32768,-32768,   416,  -259,  -122,-32768,-32768,-32768,
+-32768,   -75,  -274,  -426,  -347,-32768,   232,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,-32768,   234,-32768,  -466,
+   179,-32768,   178,-32768,   517,-32768,  -224,-32768,-32768,-32768,
+   445,  -176,-32768,-32768,-32768,-32768
+};
+
+
+#define	YYLAST		2145
+
+
+static const short yytable[] = {    76,
+    84,    29,    31,    33,    41,   104,   107,   203,   261,    43,
+    47,    19,    19,    48,    20,    20,   224,   276,   114,   197,
+   252,   194,   348,   523,    90,   286,   407,   287,    86,   313,
+   512,   178,   167,   108,    55,    36,   182,   138,   198,   379,
+   334,    42,   -93,   427,   133,   134,    86,    94,    -1,   259,
+   136,   277,   140,   569,    26,    27,   141,   135,   589,    95,
+    96,   188,   521,   204,   205,    86,    26,    27,    26,    27,
+    26,    27,    26,    27,   427,   180,   181,   599,   114,   413,
+   283,   177,   380,    37,   285,   382,   203,    90,   251,   513,
+   290,   570,    38,   138,    -2,   138,   590,   433,   436,   579,
+   318,   311,   498,  -170,   431,    36,   320,   432,   218,   179,
+   219,   558,   213,   220,   215,   600,   194,   177,   428,    34,
+   179,    86,   223,    86,   -93,   597,   194,   216,   479,   217,
+   436,   250,   194,   573,   282,   259,   256,   297,   578,   297,
+   580,   195,   406,   114,   284,    35,    28,    51,    30,   415,
+   586,   449,    32,   321,   120,   246,   247,     5,   531,     7,
+    83,    54,   322,   171,   169,     9,    10,    11,   257,   258,
+   289,    91,   252,   170,   171,    92,   392,   332,   608,   441,
+   517,    13,   333,   180,   442,   312,   411,   403,   227,   228,
+   229,   412,   232,   233,   234,   235,   236,   237,   238,   239,
+   240,   241,   242,   243,   244,   245,   307,   416,   325,   328,
+    56,   371,   541,   311,   543,   420,   311,   425,     5,   119,
+     7,   176,   126,   317,    36,   320,     9,    10,    11,   114,
+   199,   121,  -210,   483,   200,   539,   445,   169,   484,    36,
+   363,   142,    13,   179,   606,   366,   170,   171,   425,   607,
+   143,   324,   327,   206,   291,   167,    94,    92,   330,    48,
+   575,    94,   331,    36,   168,    36,    99,   175,   486,   179,
+   184,   297,   321,   201,   393,   195,   -18,   -18,   -18,   -18,
+   209,   322,   171,   210,   -18,   -18,   -18,   326,   338,    95,
+    96,   339,  -218,  -218,    95,    96,   322,   171,   357,    94,
+   -18,   214,   417,  -141,   221,   469,   418,   222,    90,  -141,
+   385,   326,  -172,   100,   393,   426,   110,   111,   112,   225,
+   322,   171,   101,     9,    10,    11,   469,   439,   373,   375,
+   405,   200,    48,   223,   408,     5,    44,     7,    45,    24,
+    25,   386,   226,     9,    10,    11,   426,    94,   357,   180,
+  -141,   358,   180,   361,  -141,   -18,   204,   205,    36,    13,
+   189,   409,   179,   -96,   -96,   -96,   -96,    95,    96,   -96,
+    59,   -96,   -96,   -96,     5,    44,     7,    45,   158,   159,
+   160,   440,     9,    10,    11,    92,   358,   -96,  -216,  -216,
+   273,    93,   435,   465,   -26,   -26,   -26,   -26,    13,   274,
+   396,   358,   -26,   -26,   -26,   280,    37,    36,    99,    46,
+   447,   257,   258,   281,   465,    38,   469,    94,   -26,   293,
+   464,  -141,   299,   602,   435,   497,   358,  -141,   300,   414,
+   301,   610,   571,   302,   572,   554,   203,   467,   308,   200,
+   468,   464,   -96,   384,   358,   358,    36,    99,   374,   305,
+    95,    96,   519,   499,   303,   100,   524,   505,   507,   309,
+   446,    48,   310,   528,   101,   556,   534,   533,  -141,    92,
+   364,   365,  -141,   -26,   478,   358,   314,   358,   540,   481,
+   156,   157,   158,   159,   160,   546,   207,   274,   419,   -22,
+   -22,   -22,   -22,   536,   100,   553,   319,   -22,   -22,   -22,
+   329,   492,   340,   101,   465,   154,   155,   156,   157,   158,
+   159,   160,    94,   -22,   161,   162,  -141,   163,   164,   165,
+   166,   343,  -141,   129,   131,   344,   346,   358,   347,   189,
+   349,   464,  -269,  -269,  -269,  -269,   548,   362,   370,   372,
+  -269,  -269,  -269,   111,   112,    95,    96,   376,   -30,     9,
+    10,    11,   399,   593,   400,   410,  -269,  -249,   437,   358,
+   542,   358,   448,  -141,   438,   443,   482,  -141,   -22,   189,
+   551,  -105,  -105,  -105,  -105,  -105,  -105,  -105,   485,  -105,
+  -105,  -105,  -105,  -105,   -31,  -105,  -105,  -105,  -105,  -105,
+  -105,  -105,  -105,  -105,  -105,  -105,  -105,  -105,   487,   490,
+  -105,   491,  -105,  -105,   493,   500,   502,   358,   494,  -105,
+   495,   -92,  -105,   508,   503,   518,   520,  -105,  -105,  -105,
+   504,   527,   530,  -105,  -105,   529,   545,   547,  -105,   549,
+   544,   550,   262,   552,   263,     5,     6,     7,     8,   574,
+   561,   264,   563,     9,    10,    11,  -105,  -105,  -105,  -105,
+   388,  -105,  -269,  -269,  -269,  -269,  -269,  -269,  -269,    13,
+  -269,  -269,  -269,  -269,  -269,   564,  -269,  -269,  -269,  -269,
+  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,   576,
+   581,  -269,   585,  -269,  -269,   588,   587,   591,   612,   595,
+  -269,   161,   162,  -269,   163,   164,   165,   166,  -269,  -269,
+  -269,   598,   613,   601,  -269,  -269,   604,   609,  -329,  -269,
+     4,    23,  -109,     5,     6,     7,     8,   249,   522,   421,
+   109,     9,    10,    11,   444,   278,   122,  -269,   402,  -269,
+  -269,   189,  -269,  -269,  -269,   260,    12,    13,  -269,  -269,
+   398,  -269,   383,   294,   298,  -269,   124,  -269,  -269,  -269,
+  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,   212,  -269,
+  -109,   422,  -269,   292,  -269,  -269,   395,   594,   596,  -109,
+   559,  -269,   560,   315,  -269,   369,     0,     0,     0,  -269,
+  -269,  -269,     0,     0,     0,  -269,  -269,    14,     0,   262,
+  -269,     0,     5,     6,     7,     8,     0,     0,   264,     0,
+     9,    10,    11,     0,     0,     0,     0,     0,  -269,   424,
+  -269,  -269,   189,  -269,  -269,  -269,    13,     0,     0,  -269,
+  -269,     0,  -269,     0,     0,     0,  -269,     0,  -269,  -269,
+  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,     0,
+  -269,     0,     0,  -269,     0,  -269,  -269,     0,     5,    44,
+     7,    45,  -269,     0,     0,  -269,     9,    10,    11,     0,
+  -269,  -269,  -269,     0,     0,  -329,  -269,  -269,     0,     0,
+     0,  -269,    13,     0,     0,     0,     0,    36,     5,    44,
+     7,    45,     0,     0,     0,     0,     9,    10,    11,  -269,
+  -250,  -269,  -269,   509,  -269,  -269,  -269,     0,     0,     0,
+  -269,  -269,    13,  -269,     0,     0,     0,  -269,     0,  -269,
+  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,  -269,
+     0,  -269,   506,     0,  -269,   326,  -269,  -269,     0,     5,
+     6,     7,     8,  -269,   322,   171,  -269,     9,    10,    11,
+     0,  -269,  -269,  -269,     0,     0,     0,  -269,  -269,     0,
+     0,     0,  -269,    13,     5,     0,     7,   176,     0,     0,
+     0,     0,     9,    10,    11,     0,     0,     0,     0,     0,
+  -269,     0,  -269,  -269,   537,  -269,  -279,  -279,    13,     0,
+     0,  -279,  -279,     0,  -279,     0,     0,     0,  -279,     0,
+  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,  -279,
+  -279,   169,  -279,     0,     0,  -279,     0,  -279,  -279,     0,
+   170,   171,     0,     0,  -279,     0,     0,  -279,     0,     0,
+     0,     0,  -279,  -279,  -279,     0,     0,     0,  -279,  -279,
+     0,     0,   137,  -279,    57,     5,     0,     7,    83,    58,
+    59,     0,    60,     9,    10,    11,     0,     0,     0,     0,
+     0,  -279,     0,  -279,  -279,     0,  -279,     0,     0,    13,
+    61,     0,     0,    62,     0,    63,    64,     0,     0,     0,
+     0,     0,    65,     0,     0,    66,     0,     0,     0,     0,
+    67,    68,    69,     0,     0,     0,    70,    71,     0,     0,
+   353,    72,   354,    27,     0,     0,     0,    58,    59,     0,
+    60,     0,     0,     0,     0,     0,     0,     5,     6,     7,
+     8,    73,    74,   368,   -82,     9,    10,    11,    61,     0,
+     0,    62,     0,    63,    64,     0,     0,     0,     0,     0,
+    65,    13,     0,    66,     0,     0,     0,     0,    67,    68,
+    69,     0,     0,     0,    70,    71,     0,     0,     0,    72,
+   355,   353,     0,   354,    27,     0,     0,     0,    58,    59,
+     0,    60,     0,     0,     0,     0,     0,     0,   397,    73,
+    74,     0,   356,     0,     0,     0,     0,     0,     0,    61,
+     0,     0,    62,     0,    63,    64,     0,     0,     0,     0,
+     0,    65,     0,     0,    66,     0,     0,     0,     0,    67,
+    68,    69,     0,     0,     0,    70,    71,     0,     0,     0,
+    72,   434,   353,     0,   354,    27,     0,     0,     0,    58,
+    59,     0,    60,     0,     0,     0,     0,     0,     0,  -207,
+    73,    74,     0,   356,     0,     0,     0,     0,     0,     0,
+    61,     0,     0,    62,     0,    63,    64,     0,     0,     0,
+     0,     0,    65,     0,     0,    66,     0,     0,     0,     0,
+    67,    68,    69,     0,     0,     0,    70,    71,     0,     0,
+     0,    72,   434,   353,     0,   354,    27,     0,     0,     0,
+    58,    59,     0,    60,     0,     0,     0,     0,     0,     0,
+   480,    73,    74,     0,   356,     0,     0,     0,     0,     0,
+     0,    61,     0,     0,    62,     0,    63,    64,     0,     0,
+     0,     0,     0,    65,     0,     0,    66,     0,     0,     0,
+     0,    67,    68,    69,     0,     0,     0,    70,    71,   353,
+     0,    57,    72,   355,     0,     0,    58,    59,     0,    60,
+   149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+   159,   160,    73,    74,     0,   356,     0,    61,     0,     0,
+    62,     0,    63,    64,     0,     0,     0,     0,     0,    65,
+     0,     0,    66,     0,     0,     0,     0,    67,    68,    69,
+     0,    57,     0,    70,    71,     0,    58,    59,    72,    60,
+     0,     0,     0,     0,    57,     0,     0,     0,     0,    58,
+    59,     0,    60,     0,     0,     0,     0,    61,    73,    74,
+    62,   356,    63,    64,     0,     0,     0,     0,     0,    65,
+    61,     0,    66,    62,     0,    63,    64,    67,    68,    69,
+     0,     0,    65,    70,    71,    66,     0,     0,    72,     0,
+    67,    68,    69,     0,     0,     0,    70,    71,    57,     0,
+     0,    72,     0,    58,    59,     0,    60,     0,    73,    74,
+     0,    57,   187,     0,     0,     0,    58,    59,     0,    60,
+     0,    73,    74,     0,    61,   255,     0,    62,     0,    63,
+    64,     0,     0,     0,     0,     0,    65,    61,     0,    66,
+    62,     0,    63,    64,    67,    68,    69,     0,     0,    65,
+    70,    71,    66,     0,     0,    72,     0,    67,    68,    69,
+     0,     0,     0,    70,    71,    57,     0,     0,    72,     0,
+    58,    59,     0,    60,     0,    73,    74,     0,     0,   288,
+   153,   154,   155,   156,   157,   158,   159,   160,    73,    74,
+     0,    61,   316,     0,    62,     0,    63,    64,   525,     0,
+     0,     0,     0,    65,     0,     0,    66,     0,     0,     0,
+     0,    67,    68,    69,     0,     0,     0,    70,    71,     0,
+     0,     0,    72,     0,   144,   145,   146,   526,   147,   148,
+   149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+   159,   160,    73,    74,     0,     0,   404,   354,   450,     6,
+     7,     8,    58,    59,     0,    60,     9,    10,    11,   451,
+     0,   452,   453,   454,   455,   456,   457,   458,   459,   460,
+   461,   462,    13,    61,     0,     0,    62,     0,    63,    64,
+     0,     0,     0,     0,     0,    65,     0,     0,    66,     0,
+     0,     0,     0,    67,    68,    69,     0,   354,    27,    70,
+    71,     0,    58,    59,    72,    60,     0,     0,     0,   451,
+     0,   452,   453,   454,   455,   456,   457,   458,   459,   460,
+   461,   462,   463,    61,    73,    74,    62,   223,    63,    64,
+     0,     0,     0,     0,     0,    65,     0,     0,    66,     0,
+     0,     0,     0,    67,    68,    69,     0,    57,     0,    70,
+    71,     0,    58,    59,    72,    60,   146,     0,   147,   148,
+   149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+   159,   160,   463,    61,    73,    74,    62,   223,    63,    64,
+     0,     0,     0,     0,     0,    65,     0,     0,    66,     0,
+     0,     0,     0,    67,    68,    69,     0,     0,     0,    70,
+    71,     0,     0,     0,    72,    57,     5,     0,     7,    83,
+    58,    59,     0,    60,     9,    10,    11,     0,     0,     0,
+     0,     0,     0,     0,    73,    74,     0,   306,     0,     0,
+    13,    61,     0,     0,    62,     0,    63,    64,     0,    57,
+     0,     0,     0,    65,    58,    59,    66,    60,     0,     0,
+     0,    67,    68,    69,     0,     0,     0,    70,    71,     0,
+     0,     0,    72,     0,     0,    61,     0,     0,    62,     0,
+    63,    64,     0,     0,     0,     0,     0,    65,     0,     0,
+    66,     0,    73,    74,     0,    67,    68,    69,     0,    57,
+     0,    70,    71,     0,    58,    59,    72,    60,     0,     0,
+     0,     0,    57,     0,     0,     0,     0,    58,    59,     0,
+    60,     0,     0,     0,   496,    61,    73,    74,    62,     0,
+    63,    64,     0,     0,     0,     0,     0,    65,    61,     0,
+    66,    62,     0,    63,    64,    67,    68,    69,     0,     0,
+    65,    70,    71,    66,     0,     0,    72,     0,    67,    68,
+    69,     0,    57,     0,    70,    71,     0,    58,    59,   128,
+    60,     0,     0,     0,     0,     0,    73,    74,   151,   152,
+   153,   154,   155,   156,   157,   158,   159,   160,    61,    73,
+    74,    62,     0,    63,    64,   429,     0,     0,     0,     0,
+    65,     0,     0,    66,     0,     0,     0,     0,    67,    68,
+    69,     0,     0,     0,    70,    71,   515,     0,     0,   130,
+     0,   144,   145,   146,     0,   147,   148,   149,   150,   151,
+   152,   153,   154,   155,   156,   157,   158,   159,   160,    73,
+    74,     0,   144,   145,   146,     0,   147,   148,   149,   150,
+   151,   152,   153,   154,   155,   156,   157,   158,   159,   160,
+     0,     0,     0,     0,     0,     0,   144,   145,   146,   430,
+   147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+   157,   158,   159,   160,     0,     0,     0,   144,   145,   146,
+   516,   147,   148,   149,   150,   151,   152,   153,   154,   155,
+   156,   157,   158,   159,   160,     0,   195,     0,     0,     0,
+     0,   144,   145,   146,   514,   147,   148,   149,   150,   151,
+   152,   153,   154,   155,   156,   157,   158,   159,   160,     0,
+     0,     0,     0,     0,     0,   562,   144,   145,   146,   568,
+   147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
+   157,   158,   159,   160,   144,   145,   146,     0,   147,   148,
+   149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
+   159,   160,   148,   149,   150,   151,   152,   153,   154,   155,
+   156,   157,   158,   159,   160,   150,   151,   152,   153,   154,
+   155,   156,   157,   158,   159,   160,   152,   153,   154,   155,
+   156,   157,   158,   159,   160
+};
+
+static const short yycheck[] = {    34,
+    35,     9,    10,    11,    18,    43,    47,   104,   184,    19,
+    20,     2,     3,    20,     2,     3,   139,   191,    49,   100,
+   170,    97,   297,   490,    38,   203,   373,   204,    35,   254,
+     1,    88,     9,    47,    32,     3,    92,    72,   101,   341,
+     1,    78,     1,   391,    63,    64,    53,    27,     0,   174,
+    69,    10,    72,    39,     3,     4,    75,    65,    39,    60,
+    61,    96,   489,    60,    61,    72,     3,     4,     3,     4,
+     3,     4,     3,     4,   422,    89,    77,    39,   109,   381,
+    77,    88,   342,    51,   202,   345,   183,   101,   169,    60,
+   208,    77,    60,   128,     0,   130,    77,   399,   400,   566,
+    77,   251,    51,    83,    79,     3,     4,    82,   128,     7,
+   130,   538,   122,   132,   124,    77,   192,   124,   393,    60,
+     7,   128,    83,   130,    83,   592,   202,   125,   430,   127,
+   432,   166,   208,   560,   197,   260,   171,   213,   565,   215,
+   567,    31,   367,   174,   200,    60,    83,    83,    83,    39,
+   577,   426,    83,    51,     1,   163,   164,     4,   505,     6,
+     7,    83,    60,    61,    51,    12,    13,    14,    60,    61,
+   205,    78,   322,    60,    61,    82,   350,    77,   605,     3,
+   482,    28,    82,   197,     8,    77,    77,   364,   143,   144,
+   145,    82,   147,   148,   149,   150,   151,   152,   153,   154,
+   155,   156,   157,   158,   159,   160,   225,   385,   265,   266,
+    83,   334,   514,   363,   516,   389,   366,   391,     4,    79,
+     6,     7,    79,   258,     3,     4,    12,    13,    14,   260,
+    78,    78,    79,    77,    82,   510,   414,    51,    82,     3,
+   321,    77,    28,     7,    77,   326,    60,    61,   422,    82,
+    82,   265,   266,    78,   209,     9,    27,    82,    78,   266,
+   562,    27,    82,     3,    77,     3,     4,    77,   446,     7,
+    60,   347,    51,     1,   350,    31,     4,     5,     6,     7,
+    37,    60,    61,    82,    12,    13,    14,    51,   279,    60,
+    61,   279,    78,    79,    60,    61,    60,    61,   306,    27,
+    28,    78,    78,    31,    77,   428,    82,    77,   322,    37,
+   348,    51,    83,    51,   390,   391,     5,     6,     7,    77,
+    60,    61,    60,    12,    13,    14,   449,    78,   338,   339,
+   365,    82,   339,    83,   375,     4,     5,     6,     7,    78,
+    79,   349,    78,    12,    13,    14,   422,    27,   356,   363,
+    78,   306,   366,   308,    82,    83,    60,    61,     3,    28,
+     1,   375,     7,     4,     5,     6,     7,    60,    61,    10,
+     9,    12,    13,    14,     4,     5,     6,     7,    51,    52,
+    53,    78,    12,    13,    14,    82,   341,    28,    78,    79,
+    84,     1,   400,   428,     4,     5,     6,     7,    28,    78,
+   355,   356,    12,    13,    14,    60,    51,     3,     4,    78,
+   418,    60,    61,    37,   449,    60,   539,    27,    28,    79,
+   428,    31,    79,   599,   432,   460,   381,    37,    79,   384,
+    77,   607,   555,    77,   557,    78,   533,   428,    39,    82,
+   428,   449,    83,    39,   399,   400,     3,     4,    78,    77,
+    60,    61,   487,   461,    79,    51,   491,   467,   468,    77,
+   415,   468,    84,   498,    60,    78,   507,   505,    78,    82,
+    60,    61,    82,    83,   429,   430,    84,   432,   513,   434,
+    49,    50,    51,    52,    53,   520,     1,    78,    79,     4,
+     5,     6,     7,   507,    51,   530,    77,    12,    13,    14,
+    77,   456,    60,    60,   539,    47,    48,    49,    50,    51,
+    52,    53,    27,    28,    55,    56,    31,    58,    59,    60,
+    61,    37,    37,    60,    61,    84,    79,   482,    82,     1,
+    33,   539,     4,     5,     6,     7,    77,    84,     3,    78,
+    12,    13,    14,     6,     7,    60,    61,     3,    39,    12,
+    13,    14,    39,   588,    82,    60,    28,    79,    79,   514,
+   515,   516,    79,    78,    84,    77,    39,    82,    83,     1,
+   525,     3,     4,     5,     6,     7,     8,     9,    77,    11,
+    12,    13,    14,    15,    39,    17,    18,    19,    20,    21,
+    22,    23,    24,    25,    26,    27,    28,    29,    60,    60,
+    32,    60,    34,    35,    39,     7,    39,   562,    78,    41,
+    78,    83,    44,    16,    78,     8,    60,    49,    50,    51,
+    78,    78,    60,    55,    56,    78,    77,    17,    60,    78,
+    82,    77,     1,    78,     3,     4,     5,     6,     7,    78,
+    77,    10,     8,    12,    13,    14,    78,    79,    80,    81,
+     1,    83,     3,     4,     5,     6,     7,     8,     9,    28,
+    11,    12,    13,    14,    15,    77,    17,    18,    19,    20,
+    21,    22,    23,    24,    25,    26,    27,    28,    29,    77,
+     9,    32,    78,    34,    35,    60,    78,    82,     0,    78,
+    41,    55,    56,    44,    58,    59,    60,    61,    49,    50,
+    51,    77,     0,    77,    55,    56,    78,    78,    77,    60,
+     1,     3,     3,     4,     5,     6,     7,   165,   490,   390,
+    48,    12,    13,    14,   412,   192,    53,    78,   363,    80,
+    81,     1,    83,     3,     4,   177,    27,    28,     8,     9,
+   356,    11,   347,   212,   215,    15,    53,    17,    18,    19,
+    20,    21,    22,    23,    24,    25,    26,    27,   118,    29,
+    51,   390,    32,   210,    34,    35,   351,   589,   591,    60,
+   539,    41,   539,   257,    44,   331,    -1,    -1,    -1,    49,
+    50,    51,    -1,    -1,    -1,    55,    56,    78,    -1,     1,
+    60,    -1,     4,     5,     6,     7,    -1,    -1,    10,    -1,
+    12,    13,    14,    -1,    -1,    -1,    -1,    -1,    78,    79,
+    80,    81,     1,    83,     3,     4,    28,    -1,    -1,     8,
+     9,    -1,    11,    -1,    -1,    -1,    15,    -1,    17,    18,
+    19,    20,    21,    22,    23,    24,    25,    26,    27,    -1,
+    29,    -1,    -1,    32,    -1,    34,    35,    -1,     4,     5,
+     6,     7,    41,    -1,    -1,    44,    12,    13,    14,    -1,
+    49,    50,    51,    -1,    -1,    77,    55,    56,    -1,    -1,
+    -1,    60,    28,    -1,    -1,    -1,    -1,     3,     4,     5,
+     6,     7,    -1,    -1,    -1,    -1,    12,    13,    14,    78,
+    79,    80,    81,     1,    83,     3,     4,    -1,    -1,    -1,
+     8,     9,    28,    11,    -1,    -1,    -1,    15,    -1,    17,
+    18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
+    -1,    29,    78,    -1,    32,    51,    34,    35,    -1,     4,
+     5,     6,     7,    41,    60,    61,    44,    12,    13,    14,
+    -1,    49,    50,    51,    -1,    -1,    -1,    55,    56,    -1,
+    -1,    -1,    60,    28,     4,    -1,     6,     7,    -1,    -1,
+    -1,    -1,    12,    13,    14,    -1,    -1,    -1,    -1,    -1,
+    78,    -1,    80,    81,     1,    83,     3,     4,    28,    -1,
+    -1,     8,     9,    -1,    11,    -1,    -1,    -1,    15,    -1,
+    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+    27,    51,    29,    -1,    -1,    32,    -1,    34,    35,    -1,
+    60,    61,    -1,    -1,    41,    -1,    -1,    44,    -1,    -1,
+    -1,    -1,    49,    50,    51,    -1,    -1,    -1,    55,    56,
+    -1,    -1,     1,    60,     3,     4,    -1,     6,     7,     8,
+     9,    -1,    11,    12,    13,    14,    -1,    -1,    -1,    -1,
+    -1,    78,    -1,    80,    81,    -1,    83,    -1,    -1,    28,
+    29,    -1,    -1,    32,    -1,    34,    35,    -1,    -1,    -1,
+    -1,    -1,    41,    -1,    -1,    44,    -1,    -1,    -1,    -1,
+    49,    50,    51,    -1,    -1,    -1,    55,    56,    -1,    -1,
+     1,    60,     3,     4,    -1,    -1,    -1,     8,     9,    -1,
+    11,    -1,    -1,    -1,    -1,    -1,    -1,     4,     5,     6,
+     7,    80,    81,    10,    83,    12,    13,    14,    29,    -1,
+    -1,    32,    -1,    34,    35,    -1,    -1,    -1,    -1,    -1,
+    41,    28,    -1,    44,    -1,    -1,    -1,    -1,    49,    50,
+    51,    -1,    -1,    -1,    55,    56,    -1,    -1,    -1,    60,
+    61,     1,    -1,     3,     4,    -1,    -1,    -1,     8,     9,
+    -1,    11,    -1,    -1,    -1,    -1,    -1,    -1,    79,    80,
+    81,    -1,    83,    -1,    -1,    -1,    -1,    -1,    -1,    29,
+    -1,    -1,    32,    -1,    34,    35,    -1,    -1,    -1,    -1,
+    -1,    41,    -1,    -1,    44,    -1,    -1,    -1,    -1,    49,
+    50,    51,    -1,    -1,    -1,    55,    56,    -1,    -1,    -1,
+    60,    61,     1,    -1,     3,     4,    -1,    -1,    -1,     8,
+     9,    -1,    11,    -1,    -1,    -1,    -1,    -1,    -1,    79,
+    80,    81,    -1,    83,    -1,    -1,    -1,    -1,    -1,    -1,
+    29,    -1,    -1,    32,    -1,    34,    35,    -1,    -1,    -1,
+    -1,    -1,    41,    -1,    -1,    44,    -1,    -1,    -1,    -1,
+    49,    50,    51,    -1,    -1,    -1,    55,    56,    -1,    -1,
+    -1,    60,    61,     1,    -1,     3,     4,    -1,    -1,    -1,
+     8,     9,    -1,    11,    -1,    -1,    -1,    -1,    -1,    -1,
+    79,    80,    81,    -1,    83,    -1,    -1,    -1,    -1,    -1,
+    -1,    29,    -1,    -1,    32,    -1,    34,    35,    -1,    -1,
+    -1,    -1,    -1,    41,    -1,    -1,    44,    -1,    -1,    -1,
+    -1,    49,    50,    51,    -1,    -1,    -1,    55,    56,     1,
+    -1,     3,    60,    61,    -1,    -1,     8,     9,    -1,    11,
+    42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+    52,    53,    80,    81,    -1,    83,    -1,    29,    -1,    -1,
+    32,    -1,    34,    35,    -1,    -1,    -1,    -1,    -1,    41,
+    -1,    -1,    44,    -1,    -1,    -1,    -1,    49,    50,    51,
+    -1,     3,    -1,    55,    56,    -1,     8,     9,    60,    11,
+    -1,    -1,    -1,    -1,     3,    -1,    -1,    -1,    -1,     8,
+     9,    -1,    11,    -1,    -1,    -1,    -1,    29,    80,    81,
+    32,    83,    34,    35,    -1,    -1,    -1,    -1,    -1,    41,
+    29,    -1,    44,    32,    -1,    34,    35,    49,    50,    51,
+    -1,    -1,    41,    55,    56,    44,    -1,    -1,    60,    -1,
+    49,    50,    51,    -1,    -1,    -1,    55,    56,     3,    -1,
+    -1,    60,    -1,     8,     9,    -1,    11,    -1,    80,    81,
+    -1,     3,    84,    -1,    -1,    -1,     8,     9,    -1,    11,
+    -1,    80,    81,    -1,    29,    84,    -1,    32,    -1,    34,
+    35,    -1,    -1,    -1,    -1,    -1,    41,    29,    -1,    44,
+    32,    -1,    34,    35,    49,    50,    51,    -1,    -1,    41,
+    55,    56,    44,    -1,    -1,    60,    -1,    49,    50,    51,
+    -1,    -1,    -1,    55,    56,     3,    -1,    -1,    60,    -1,
+     8,     9,    -1,    11,    -1,    80,    81,    -1,    -1,    84,
+    46,    47,    48,    49,    50,    51,    52,    53,    80,    81,
+    -1,    29,    84,    -1,    32,    -1,    34,    35,    10,    -1,
+    -1,    -1,    -1,    41,    -1,    -1,    44,    -1,    -1,    -1,
+    -1,    49,    50,    51,    -1,    -1,    -1,    55,    56,    -1,
+    -1,    -1,    60,    -1,    36,    37,    38,    39,    40,    41,
+    42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+    52,    53,    80,    81,    -1,    -1,    84,     3,     4,     5,
+     6,     7,     8,     9,    -1,    11,    12,    13,    14,    15,
+    -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    26,    27,    28,    29,    -1,    -1,    32,    -1,    34,    35,
+    -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,    44,    -1,
+    -1,    -1,    -1,    49,    50,    51,    -1,     3,     4,    55,
+    56,    -1,     8,     9,    60,    11,    -1,    -1,    -1,    15,
+    -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
+    26,    27,    78,    29,    80,    81,    32,    83,    34,    35,
+    -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,    44,    -1,
+    -1,    -1,    -1,    49,    50,    51,    -1,     3,    -1,    55,
+    56,    -1,     8,     9,    60,    11,    38,    -1,    40,    41,
+    42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+    52,    53,    78,    29,    80,    81,    32,    83,    34,    35,
+    -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,    44,    -1,
+    -1,    -1,    -1,    49,    50,    51,    -1,    -1,    -1,    55,
+    56,    -1,    -1,    -1,    60,     3,     4,    -1,     6,     7,
+     8,     9,    -1,    11,    12,    13,    14,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    80,    81,    -1,    83,    -1,    -1,
+    28,    29,    -1,    -1,    32,    -1,    34,    35,    -1,     3,
+    -1,    -1,    -1,    41,     8,     9,    44,    11,    -1,    -1,
+    -1,    49,    50,    51,    -1,    -1,    -1,    55,    56,    -1,
+    -1,    -1,    60,    -1,    -1,    29,    -1,    -1,    32,    -1,
+    34,    35,    -1,    -1,    -1,    -1,    -1,    41,    -1,    -1,
+    44,    -1,    80,    81,    -1,    49,    50,    51,    -1,     3,
+    -1,    55,    56,    -1,     8,     9,    60,    11,    -1,    -1,
+    -1,    -1,     3,    -1,    -1,    -1,    -1,     8,     9,    -1,
+    11,    -1,    -1,    -1,    78,    29,    80,    81,    32,    -1,
+    34,    35,    -1,    -1,    -1,    -1,    -1,    41,    29,    -1,
+    44,    32,    -1,    34,    35,    49,    50,    51,    -1,    -1,
+    41,    55,    56,    44,    -1,    -1,    60,    -1,    49,    50,
+    51,    -1,     3,    -1,    55,    56,    -1,     8,     9,    60,
+    11,    -1,    -1,    -1,    -1,    -1,    80,    81,    44,    45,
+    46,    47,    48,    49,    50,    51,    52,    53,    29,    80,
+    81,    32,    -1,    34,    35,    10,    -1,    -1,    -1,    -1,
+    41,    -1,    -1,    44,    -1,    -1,    -1,    -1,    49,    50,
+    51,    -1,    -1,    -1,    55,    56,    10,    -1,    -1,    60,
+    -1,    36,    37,    38,    -1,    40,    41,    42,    43,    44,
+    45,    46,    47,    48,    49,    50,    51,    52,    53,    80,
+    81,    -1,    36,    37,    38,    -1,    40,    41,    42,    43,
+    44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+    -1,    -1,    -1,    -1,    -1,    -1,    36,    37,    38,    84,
+    40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+    50,    51,    52,    53,    -1,    -1,    -1,    36,    37,    38,
+    84,    40,    41,    42,    43,    44,    45,    46,    47,    48,
+    49,    50,    51,    52,    53,    -1,    31,    -1,    -1,    -1,
+    -1,    36,    37,    38,    84,    40,    41,    42,    43,    44,
+    45,    46,    47,    48,    49,    50,    51,    52,    53,    -1,
+    -1,    -1,    -1,    -1,    -1,    84,    36,    37,    38,    39,
+    40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+    50,    51,    52,    53,    36,    37,    38,    -1,    40,    41,
+    42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+    52,    53,    41,    42,    43,    44,    45,    46,    47,    48,
+    49,    50,    51,    52,    53,    43,    44,    45,    46,    47,
+    48,    49,    50,    51,    52,    53,    45,    46,    47,    48,
+    49,    50,    51,    52,    53
+};
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "bison.simple"
+
+/* Skeleton output parser for bison,
+   Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
+
+   This program 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 1, or (at your option)
+   any later version.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+#ifndef alloca
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not GNU C.  */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
+#include <alloca.h>
+#else /* not sparc */
+#if defined (MSDOS) && !defined (__TURBOC__)
+#include <malloc.h>
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+#include <malloc.h>
+ #pragma alloca
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc.  */
+#endif /* not GNU C.  */
+#endif /* alloca not defined.  */
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		-2
+#define YYEOF		0
+#define YYACCEPT	return(0)
+#define YYABORT 	return(1)
+#define YYERROR		goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+#define YYFAIL		goto yyerrlab
+#define YYRECOVERING()  (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    { yychar = (token), yylval = (value);			\
+      yychar1 = YYTRANSLATE (yychar);				\
+      YYPOPSTACK;						\
+      goto yybackup;						\
+    }								\
+  else								\
+    { yyerror ("syntax error: cannot back up"); YYERROR; }	\
+while (0)
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+#ifndef YYPURE
+#define YYLEX		yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#define YYLEX		yylex(&yylval, &yylloc)
+#else
+#define YYLEX		yylex(&yylval)
+#endif
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+int	yychar;			/*  the lookahead symbol		*/
+YYSTYPE	yylval;			/*  the semantic value of the		*/
+				/*  lookahead symbol			*/
+
+#ifdef YYLSP_NEEDED
+YYLTYPE yylloc;			/*  location data for the lookahead	*/
+				/*  symbol				*/
+#endif
+
+int yynerrs;			/*  number of parse errors so far       */
+#endif  /* not YYPURE */
+
+#if YYDEBUG != 0
+int yydebug;			/*  nonzero means print parse trace	*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
+#endif
+
+/*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
+
+#ifndef	YYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
+#define __yy_bcopy(FROM,TO,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
+#else				/* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_bcopy (from, to, count)
+     char *from;
+     char *to;
+     int count;
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_bcopy (char *from, char *to, int count)
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#endif
+#endif
+
+#line 169 "bison.simple"
+int
+yyparse()
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
+  int yychar1;		/*  lookahead token as an internal (translated) token number */
+
+  short	yyssa[YYINITDEPTH];	/*  the state stack			*/
+  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
+
+  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
+  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+
+#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
+#define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
+
+  int yystacksize = YYINITDEPTH;
+
+#ifdef YYPURE
+  int yychar;
+  YYSTYPE yylval;
+  int yynerrs;
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylloc;
+#endif
+#endif
+
+  YYSTYPE yyval;		/*  the variable used to return		*/
+				/*  semantic values from the action	*/
+				/*  routines				*/
+
+  int yylen;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.  */
+
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+  yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
+
+  *++yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *yyvs1 = yyvs;
+      short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+      YYLTYPE *yyls1 = yyls;
+#endif
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      /* Each stack pointer address is followed by the size of
+	 the data in use in that stack, in bytes.  */
+      yyoverflow("parser stack overflow",
+		 &yyss1, size * sizeof (*yyssp),
+		 &yyvs1, size * sizeof (*yyvsp),
+#ifdef YYLSP_NEEDED
+		 &yyls1, size * sizeof (*yylsp),
+#endif
+		 &yystacksize);
+
+      yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+      yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+      /* Extend the stack our own way.  */
+      if (yystacksize >= YYMAXDEPTH)
+	{
+	  yyerror("parser stack overflow");
+	  return 2;
+	}
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+	yystacksize = YYMAXDEPTH;
+      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+      __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
+      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+      __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+      __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+      if (yyssp >= yyss + yystacksize - 1)
+	YYABORT;
+    }
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+ yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Reading a token: ");
+#endif
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+  if (yychar <= 0)		/* This means end of input. */
+    {
+      yychar1 = 0;
+      yychar = YYEOF;		/* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Now at end of input.\n");
+#endif
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+      if (yydebug)
+	{
+	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+	  /* Give the individual parser a way to print the precise meaning
+	     of a token, for further debugging info.  */
+#ifdef YYPRINT
+	  YYPRINT (stderr, yychar, yylval);
+#endif
+	  fprintf (stderr, ")\n");
+	}
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+/* Do the default action for the current state.  */
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+yyreduce:
+  yylen = yyr2[yyn];
+  yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      int i;
+
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+	       yyn, yyrline[yyn]);
+
+      /* Print the symboles being reduced, and their result.  */
+      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
+
+
+  switch (yyn) {
+
+case 1:
+#line 219 "c-parse.y"
+{ if (pedantic)
+		    pedwarn ("ANSI C forbids an empty source file");
+		;
+    break;}
+case 2:
+#line 223 "c-parse.y"
+{
+		  /* In case there were missing closebraces,
+		     get us back to the global binding level.  */
+		  while (! global_bindings_p ())
+		    poplevel (0, 0, 0);
+		;
+    break;}
+case 3:
+#line 236 "c-parse.y"
+{yyval.ttype = NULL_TREE; ;
+    break;}
+case 5:
+#line 237 "c-parse.y"
+{yyval.ttype = NULL_TREE; ;
+    break;}
+case 9:
+#line 244 "c-parse.y"
+{ STRIP_NOPS (yyvsp[-2].ttype);
+		  if ((TREE_CODE (yyvsp[-2].ttype) == ADDR_EXPR
+		       && TREE_CODE (TREE_OPERAND (yyvsp[-2].ttype, 0)) == STRING_CST)
+		      || TREE_CODE (yyvsp[-2].ttype) == STRING_CST)
+		    assemble_asm (yyvsp[-2].ttype);
+		  else
+		    error ("argument of `asm' is not a constant string"); ;
+    break;}
+case 10:
+#line 255 "c-parse.y"
+{ if (pedantic)
+		    error ("ANSI C forbids data definition with no type or storage class");
+		  else if (!flag_traditional)
+		    warning ("data definition has no type or storage class"); ;
+    break;}
+case 11:
+#line 260 "c-parse.y"
+{;
+    break;}
+case 12:
+#line 262 "c-parse.y"
+{;
+    break;}
+case 13:
+#line 264 "c-parse.y"
+{ pedwarn ("empty declaration"); ;
+    break;}
+case 14:
+#line 266 "c-parse.y"
+{ shadow_tag (yyvsp[-1].ttype); ;
+    break;}
+case 17:
+#line 270 "c-parse.y"
+{ if (pedantic)
+		    pedwarn ("ANSI C does not allow extra `;' outside of a function"); ;
+    break;}
+case 18:
+#line 276 "c-parse.y"
+{ if (! start_function (yyvsp[-2].ttype, yyvsp[0].ttype, 0))
+		    YYERROR1;
+		  reinit_parse_for_function (); ;
+    break;}
+case 19:
+#line 280 "c-parse.y"
+{ store_parm_decls (); ;
+    break;}
+case 20:
+#line 282 "c-parse.y"
+{ finish_function (0); ;
+    break;}
+case 21:
+#line 284 "c-parse.y"
+{ ;
+    break;}
+case 22:
+#line 286 "c-parse.y"
+{ if (! start_function (yyvsp[-2].ttype, yyvsp[0].ttype, 0))
+		    YYERROR1;
+		  reinit_parse_for_function (); ;
+    break;}
+case 23:
+#line 290 "c-parse.y"
+{ store_parm_decls (); ;
+    break;}
+case 24:
+#line 292 "c-parse.y"
+{ finish_function (0); ;
+    break;}
+case 25:
+#line 294 "c-parse.y"
+{ ;
+    break;}
+case 26:
+#line 296 "c-parse.y"
+{ if (! start_function (NULL_TREE, yyvsp[0].ttype, 0))
+		    YYERROR1;
+		  reinit_parse_for_function (); ;
+    break;}
+case 27:
+#line 300 "c-parse.y"
+{ store_parm_decls (); ;
+    break;}
+case 28:
+#line 302 "c-parse.y"
+{ finish_function (0); ;
+    break;}
+case 29:
+#line 304 "c-parse.y"
+{ ;
+    break;}
+case 32:
+#line 313 "c-parse.y"
+{ yyval.code = ADDR_EXPR; ;
+    break;}
+case 33:
+#line 315 "c-parse.y"
+{ yyval.code = NEGATE_EXPR; ;
+    break;}
+case 34:
+#line 317 "c-parse.y"
+{ yyval.code = CONVERT_EXPR; ;
+    break;}
+case 35:
+#line 319 "c-parse.y"
+{ yyval.code = PREINCREMENT_EXPR; ;
+    break;}
+case 36:
+#line 321 "c-parse.y"
+{ yyval.code = PREDECREMENT_EXPR; ;
+    break;}
+case 37:
+#line 323 "c-parse.y"
+{ yyval.code = BIT_NOT_EXPR; ;
+    break;}
+case 38:
+#line 325 "c-parse.y"
+{ yyval.code = TRUTH_NOT_EXPR; ;
+    break;}
+case 39:
+#line 329 "c-parse.y"
+{ yyval.ttype = build_compound_expr (yyvsp[0].ttype); ;
+    break;}
+case 40:
+#line 334 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 42:
+#line 340 "c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+    break;}
+case 43:
+#line 342 "c-parse.y"
+{ chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
+    break;}
+case 45:
+#line 348 "c-parse.y"
+{ yyval.ttype = build_indirect_ref (yyvsp[0].ttype, "unary *"); ;
+    break;}
+case 46:
+#line 351 "c-parse.y"
+{ yyvsp[0].itype = pedantic;
+		  pedantic = 0; ;
+    break;}
+case 47:
+#line 354 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+		  pedantic = yyvsp[-2].itype; ;
+    break;}
+case 48:
+#line 357 "c-parse.y"
+{ yyval.ttype = build_unary_op (yyvsp[-1].code, yyvsp[0].ttype, 0);
+		  overflow_warning (yyval.ttype); ;
+    break;}
+case 49:
+#line 361 "c-parse.y"
+{ tree label = lookup_label (yyvsp[0].ttype);
+		  if (label == 0)
+		    yyval.ttype = null_pointer_node;
+		  else
+		    {
+		      TREE_USED (label) = 1;
+		      yyval.ttype = build1 (ADDR_EXPR, ptr_type_node, label);
+		      TREE_CONSTANT (yyval.ttype) = 1;
+		    }
+		;
+    break;}
+case 50:
+#line 387 "c-parse.y"
+{ if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF
+		      && DECL_BIT_FIELD (TREE_OPERAND (yyvsp[0].ttype, 1)))
+		    error ("`sizeof' applied to a bit-field");
+		  yyval.ttype = c_sizeof (TREE_TYPE (yyvsp[0].ttype)); ;
+    break;}
+case 51:
+#line 392 "c-parse.y"
+{ yyval.ttype = c_sizeof (groktypename (yyvsp[-1].ttype)); ;
+    break;}
+case 52:
+#line 394 "c-parse.y"
+{ yyval.ttype = c_alignof_expr (yyvsp[0].ttype); ;
+    break;}
+case 53:
+#line 396 "c-parse.y"
+{ yyval.ttype = c_alignof (groktypename (yyvsp[-1].ttype)); ;
+    break;}
+case 54:
+#line 398 "c-parse.y"
+{ yyval.ttype = build_unary_op (REALPART_EXPR, yyvsp[0].ttype, 0); ;
+    break;}
+case 55:
+#line 400 "c-parse.y"
+{ yyval.ttype = build_unary_op (IMAGPART_EXPR, yyvsp[0].ttype, 0); ;
+    break;}
+case 57:
+#line 406 "c-parse.y"
+{ tree type = groktypename (yyvsp[-2].ttype);
+		  yyval.ttype = build_c_cast (type, yyvsp[0].ttype); ;
+    break;}
+case 58:
+#line 409 "c-parse.y"
+{ tree type = groktypename (yyvsp[-5].ttype);
+		  char *name;
+		  if (pedantic)
+		    pedwarn ("ANSI C forbids constructor expressions");
+		  if (TYPE_NAME (type) != 0)
+		    {
+		      if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
+			name = IDENTIFIER_POINTER (TYPE_NAME (type));
+		      else
+			name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+		    }
+		  else
+		    name = "";
+		  yyval.ttype = digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype)),
+				    NULL_PTR, 0, 0, name);
+		  if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
+		    {
+		      int failure = complete_array_type (type, yyval.ttype, 1);
+		      if (failure)
+			abort ();
+		    }
+		;
+    break;}
+case 60:
+#line 436 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 61:
+#line 438 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 62:
+#line 440 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 63:
+#line 442 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 64:
+#line 444 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 65:
+#line 446 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 66:
+#line 448 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 67:
+#line 450 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 68:
+#line 452 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 69:
+#line 454 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 70:
+#line 456 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 71:
+#line 458 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 72:
+#line 460 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (TRUTH_ANDIF_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 73:
+#line 462 "c-parse.y"
+{ yyval.ttype = parser_build_binary_op (TRUTH_ORIF_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 74:
+#line 464 "c-parse.y"
+{ yyval.ttype = build_conditional_expr (yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 75:
+#line 466 "c-parse.y"
+{ yyval.ttype = build_modify_expr (yyvsp[-2].ttype, NOP_EXPR, yyvsp[0].ttype);
+		  C_SET_EXP_ORIGINAL_CODE (yyval.ttype, MODIFY_EXPR); ;
+    break;}
+case 76:
+#line 469 "c-parse.y"
+{ yyval.ttype = build_modify_expr (yyvsp[-2].ttype, yyvsp[-1].code, yyvsp[0].ttype);
+		  /* This inhibits warnings in truthvalue_conversion.  */
+		  C_SET_EXP_ORIGINAL_CODE (yyval.ttype, ERROR_MARK); ;
+    break;}
+case 77:
+#line 476 "c-parse.y"
+{
+		  tree context;
+
+		  yyval.ttype = lastiddecl;
+		  if (!yyval.ttype || yyval.ttype == error_mark_node)
+		    {
+		      if (yychar == YYEMPTY)
+			yychar = YYLEX;
+		      if (yychar == '(')
+			{
+			    {
+			      /* Ordinary implicit function declaration.  */
+			      yyval.ttype = implicitly_declare (yyvsp[0].ttype);
+			      assemble_external (yyval.ttype);
+			      TREE_USED (yyval.ttype) = 1;
+			    }
+			}
+		      else if (current_function_decl == 0)
+			{
+			  error ("`%s' undeclared here (not in a function)",
+				 IDENTIFIER_POINTER (yyvsp[0].ttype));
+			  yyval.ttype = error_mark_node;
+			}
+		      else
+			{
+			    {
+			      if (IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype) != error_mark_node
+				  || IDENTIFIER_ERROR_LOCUS (yyvsp[0].ttype) != current_function_decl)
+				{
+				  error ("`%s' undeclared (first use this function)",
+					 IDENTIFIER_POINTER (yyvsp[0].ttype));
+
+				  if (! undeclared_variable_notice)
+				    {
+				      error ("(Each undeclared identifier is reported only once");
+				      error ("for each function it appears in.)");
+				      undeclared_variable_notice = 1;
+				    }
+				}
+			      yyval.ttype = error_mark_node;
+			      /* Prevent repeated error messages.  */
+			      IDENTIFIER_GLOBAL_VALUE (yyvsp[0].ttype) = error_mark_node;
+			      IDENTIFIER_ERROR_LOCUS (yyvsp[0].ttype) = current_function_decl;
+			    }
+			}
+		    }
+		  else if (TREE_TYPE (yyval.ttype) == error_mark_node)
+		    yyval.ttype = error_mark_node;
+		  else if (C_DECL_ANTICIPATED (yyval.ttype))
+		    {
+		      /* The first time we see a build-in function used,
+			 if it has not been declared.  */
+		      C_DECL_ANTICIPATED (yyval.ttype) = 0;
+		      if (yychar == YYEMPTY)
+			yychar = YYLEX;
+		      if (yychar == '(')
+			{
+			  /* Omit the implicit declaration we
+			     would ordinarily do, so we don't lose
+			     the actual built in type.
+			     But print a diagnostic for the mismatch.  */
+			    if (TREE_CODE (yyval.ttype) != FUNCTION_DECL)
+			      error ("`%s' implicitly declared as function",
+				     IDENTIFIER_POINTER (DECL_NAME (yyval.ttype)));
+			  else if ((TYPE_MODE (TREE_TYPE (TREE_TYPE (yyval.ttype)))
+				    != TYPE_MODE (integer_type_node))
+				   && (TREE_TYPE (TREE_TYPE (yyval.ttype))
+				       != void_type_node))
+			    pedwarn ("type mismatch in implicit declaration for built-in function `%s'",
+				     IDENTIFIER_POINTER (DECL_NAME (yyval.ttype)));
+			  /* If it really returns void, change that to int.  */
+			  if (TREE_TYPE (TREE_TYPE (yyval.ttype)) == void_type_node)
+			    TREE_TYPE (yyval.ttype)
+			      = build_function_type (integer_type_node,
+						     TYPE_ARG_TYPES (TREE_TYPE (yyval.ttype)));
+			}
+		      else
+			pedwarn ("built-in function `%s' used without declaration",
+				 IDENTIFIER_POINTER (DECL_NAME (yyval.ttype)));
+
+		      /* Do what we would ordinarily do when a fn is used.  */
+		      assemble_external (yyval.ttype);
+		      TREE_USED (yyval.ttype) = 1;
+		    }
+		  else
+		    {
+		      assemble_external (yyval.ttype);
+		      TREE_USED (yyval.ttype) = 1;
+		    }
+
+		  if (TREE_CODE (yyval.ttype) == CONST_DECL)
+		    {
+		      yyval.ttype = DECL_INITIAL (yyval.ttype);
+		      /* This is to prevent an enum whose value is 0
+			 from being considered a null pointer constant.  */
+		      yyval.ttype = build1 (NOP_EXPR, TREE_TYPE (yyval.ttype), yyval.ttype);
+		      TREE_CONSTANT (yyval.ttype) = 1;
+		    }
+		;
+    break;}
+case 79:
+#line 577 "c-parse.y"
+{ yyval.ttype = combine_strings (yyvsp[0].ttype); ;
+    break;}
+case 80:
+#line 579 "c-parse.y"
+{ char class = TREE_CODE_CLASS (TREE_CODE (yyvsp[-1].ttype));
+		  if (class == 'e' || class == '1'
+		      || class == '2' || class == '<')
+		    C_SET_EXP_ORIGINAL_CODE (yyvsp[-1].ttype, ERROR_MARK);
+		  yyval.ttype = yyvsp[-1].ttype; ;
+    break;}
+case 81:
+#line 585 "c-parse.y"
+{ yyval.ttype = error_mark_node; ;
+    break;}
+case 82:
+#line 587 "c-parse.y"
+{ if (current_function_decl == 0)
+		    {
+		      error ("braced-group within expression allowed only inside a function");
+		      YYERROR;
+		    }
+		  /* We must force a BLOCK for this level
+		     so that, if it is not expanded later,
+		     there is a way to turn off the entire subtree of blocks
+		     that are contained in it.  */
+		  keep_next_level ();
+		  push_iterator_stack ();
+		  push_label_level ();
+		  yyval.ttype = expand_start_stmt_expr (); ;
+    break;}
+case 83:
+#line 601 "c-parse.y"
+{ tree rtl_exp;
+		  if (pedantic)
+		    pedwarn ("ANSI C forbids braced-groups within expressions");
+		  pop_iterator_stack ();
+		  pop_label_level ();
+		  rtl_exp = expand_end_stmt_expr (yyvsp[-2].ttype);
+		  /* The statements have side effects, so the group does.  */
+		  TREE_SIDE_EFFECTS (rtl_exp) = 1;
+
+		  /* Make a BIND_EXPR for the BLOCK already made.  */
+		  yyval.ttype = build (BIND_EXPR, TREE_TYPE (rtl_exp),
+			      NULL_TREE, rtl_exp, yyvsp[-1].ttype);
+		  /* Remove the block from the tree at this point.
+		     It gets put back at the proper place
+		     when the BIND_EXPR is expanded.  */
+		  delete_block (yyvsp[-1].ttype);
+		;
+    break;}
+case 84:
+#line 619 "c-parse.y"
+{ yyval.ttype = build_function_call (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 85:
+#line 621 "c-parse.y"
+{ yyval.ttype = build_array_ref (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 86:
+#line 623 "c-parse.y"
+{
+		    yyval.ttype = build_component_ref (yyvsp[-2].ttype, yyvsp[0].ttype);
+		;
+    break;}
+case 87:
+#line 627 "c-parse.y"
+{
+                  tree expr = build_indirect_ref (yyvsp[-2].ttype, "->");
+
+                    yyval.ttype = build_component_ref (expr, yyvsp[0].ttype);
+		;
+    break;}
+case 88:
+#line 633 "c-parse.y"
+{ yyval.ttype = build_unary_op (POSTINCREMENT_EXPR, yyvsp[-1].ttype, 0); ;
+    break;}
+case 89:
+#line 635 "c-parse.y"
+{ yyval.ttype = build_unary_op (POSTDECREMENT_EXPR, yyvsp[-1].ttype, 0); ;
+    break;}
+case 91:
+#line 642 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 94:
+#line 651 "c-parse.y"
+{ c_mark_varargs ();
+		  if (pedantic)
+		    pedwarn ("ANSI C does not permit use of `varargs.h'"); ;
+    break;}
+case 95:
+#line 661 "c-parse.y"
+{ ;
+    break;}
+case 100:
+#line 673 "c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-2].itype); ;
+    break;}
+case 101:
+#line 677 "c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-2].itype); ;
+    break;}
+case 102:
+#line 681 "c-parse.y"
+{ shadow_tag_warned (yyvsp[-1].ttype, 1);
+		  pedwarn ("empty declaration"); ;
+    break;}
+case 103:
+#line 684 "c-parse.y"
+{ pedwarn ("empty declaration"); ;
+    break;}
+case 104:
+#line 693 "c-parse.y"
+{ ;
+    break;}
+case 109:
+#line 708 "c-parse.y"
+{ yyval.itype = suspend_momentary ();
+		  pending_xref_error ();
+		  declspec_stack = tree_cons (NULL_TREE, current_declspecs,
+					      declspec_stack);
+		  current_declspecs = yyvsp[0].ttype; ;
+    break;}
+case 110:
+#line 717 "c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-2].itype); ;
+    break;}
+case 111:
+#line 721 "c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-2].itype); ;
+    break;}
+case 112:
+#line 725 "c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-1].itype); ;
+    break;}
+case 113:
+#line 729 "c-parse.y"
+{ current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-1].itype); ;
+    break;}
+case 114:
+#line 733 "c-parse.y"
+{ shadow_tag (yyvsp[-1].ttype); ;
+    break;}
+case 115:
+#line 735 "c-parse.y"
+{ pedwarn ("empty declaration"); ;
+    break;}
+case 116:
+#line 744 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 117:
+#line 746 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
+    break;}
+case 118:
+#line 750 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 119:
+#line 752 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 120:
+#line 754 "c-parse.y"
+{ if (extra_warnings)
+		    warning ("`%s' is not at beginning of declaration",
+			     IDENTIFIER_POINTER (yyvsp[0].ttype));
+		  yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 121:
+#line 766 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE);
+		  TREE_STATIC (yyval.ttype) = 1; ;
+    break;}
+case 122:
+#line 769 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 123:
+#line 771 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype);
+		  TREE_STATIC (yyval.ttype) = 1; ;
+    break;}
+case 124:
+#line 774 "c-parse.y"
+{ if (extra_warnings && TREE_STATIC (yyvsp[-1].ttype))
+		    warning ("`%s' is not at beginning of declaration",
+			     IDENTIFIER_POINTER (yyvsp[0].ttype));
+		  yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype);
+		  TREE_STATIC (yyval.ttype) = TREE_STATIC (yyvsp[-1].ttype); ;
+    break;}
+case 125:
+#line 788 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 126:
+#line 790 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
+    break;}
+case 127:
+#line 794 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 128:
+#line 796 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 131:
+#line 806 "c-parse.y"
+{ /* For a typedef name, record the meaning, not the name.
+		     In case of `foo foo, bar;'.  */
+		  yyval.ttype = lookup_name (yyvsp[0].ttype); ;
+    break;}
+case 132:
+#line 810 "c-parse.y"
+{ yyval.ttype = TREE_TYPE (yyvsp[-1].ttype); ;
+    break;}
+case 133:
+#line 812 "c-parse.y"
+{ yyval.ttype = groktypename (yyvsp[-1].ttype); ;
+    break;}
+case 141:
+#line 834 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 142:
+#line 836 "c-parse.y"
+{ if (TREE_CHAIN (yyvsp[-1].ttype)) yyvsp[-1].ttype = combine_strings (yyvsp[-1].ttype);
+		  yyval.ttype = yyvsp[-1].ttype;
+		;
+    break;}
+case 143:
+#line 843 "c-parse.y"
+{ yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 1); ;
+    break;}
+case 144:
+#line 846 "c-parse.y"
+{ decl_attributes (yyvsp[-1].ttype, yyvsp[-3].ttype);
+		  finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
+    break;}
+case 145:
+#line 849 "c-parse.y"
+{ tree d = start_decl (yyvsp[-2].ttype, current_declspecs, 0);
+		  decl_attributes (d, yyvsp[0].ttype);
+		  finish_decl (d, NULL_TREE, yyvsp[-1].ttype); ;
+    break;}
+case 146:
+#line 856 "c-parse.y"
+{ yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 1); ;
+    break;}
+case 147:
+#line 859 "c-parse.y"
+{ decl_attributes (yyvsp[-1].ttype, yyvsp[-3].ttype);
+		  finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
+    break;}
+case 148:
+#line 862 "c-parse.y"
+{ tree d = start_decl (yyvsp[-2].ttype, current_declspecs, 0);
+		  decl_attributes (d, yyvsp[0].ttype);
+		  finish_decl (d, NULL_TREE, yyvsp[-1].ttype); ;
+    break;}
+case 149:
+#line 870 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 150:
+#line 872 "c-parse.y"
+{ yyval.ttype = yyvsp[-2].ttype; ;
+    break;}
+case 151:
+#line 877 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 152:
+#line 879 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-2].ttype); ;
+    break;}
+case 153:
+#line 884 "c-parse.y"
+{ if (strcmp (IDENTIFIER_POINTER (yyvsp[0].ttype), "packed"))
+	    warning ("`%s' attribute directive ignored",
+		     IDENTIFIER_POINTER (yyvsp[0].ttype));
+	  yyval.ttype = yyvsp[0].ttype; ;
+    break;}
+case 154:
+#line 889 "c-parse.y"
+{ /* If not "mode (m)", then issue warning.  */
+	  if (strcmp (IDENTIFIER_POINTER (yyvsp[-3].ttype), "mode") != 0)
+	    {
+	      warning ("`%s' attribute directive ignored",
+		       IDENTIFIER_POINTER (yyvsp[-3].ttype));
+	      yyval.ttype = yyvsp[-3].ttype;
+	    }
+	  else
+	    yyval.ttype = tree_cons (yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE); ;
+    break;}
+case 155:
+#line 899 "c-parse.y"
+{ /* if not "aligned(n)", then issue warning */
+	  if (strcmp (IDENTIFIER_POINTER (yyvsp[-3].ttype), "aligned") != 0
+	      || TREE_CODE (yyvsp[-1].ttype) != INTEGER_CST)
+	    {
+	      warning ("`%s' attribute directive ignored",
+		       IDENTIFIER_POINTER (yyvsp[-3].ttype));
+	      yyval.ttype = yyvsp[-3].ttype;
+	    }
+	  else
+	    yyval.ttype = tree_cons (yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE); ;
+    break;}
+case 156:
+#line 910 "c-parse.y"
+{ /* if not "format(...)", then issue warning */
+	  if (strcmp (IDENTIFIER_POINTER (yyvsp[-7].ttype), "format") != 0
+	      || TREE_CODE (yyvsp[-3].ttype) != INTEGER_CST
+	      || TREE_CODE (yyvsp[-1].ttype) != INTEGER_CST)
+	    {
+	      warning ("`%s' attribute directive ignored",
+		       IDENTIFIER_POINTER (yyvsp[-7].ttype));
+	      yyval.ttype = yyvsp[-7].ttype;
+	    }
+	  else
+	    yyval.ttype = tree_cons (yyvsp[-7].ttype,
+			    tree_cons (yyvsp[-5].ttype,
+				       tree_cons (yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE),
+				       NULL_TREE),
+			    NULL_TREE); ;
+    break;}
+case 158:
+#line 930 "c-parse.y"
+{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE);
+		  if (pedantic)
+		    pedwarn ("ANSI C forbids empty initializer braces"); ;
+    break;}
+case 159:
+#line 934 "c-parse.y"
+{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-1].ttype)); ;
+    break;}
+case 160:
+#line 936 "c-parse.y"
+{ yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype)); ;
+    break;}
+case 161:
+#line 938 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 162:
+#line 945 "c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+    break;}
+case 163:
+#line 947 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-2].ttype); ;
+    break;}
+case 164:
+#line 952 "c-parse.y"
+{ yyval.ttype = build_tree_list (tree_cons (yyvsp[-4].ttype, NULL_TREE,
+						   build_tree_list (yyvsp[-2].ttype, NULL_TREE)),
+					yyvsp[0].ttype); ;
+    break;}
+case 165:
+#line 956 "c-parse.y"
+{ yyval.ttype = tree_cons (tree_cons (yyvsp[-4].ttype, NULL_TREE,
+					     build_tree_list (yyvsp[-2].ttype, NULL_TREE)),
+				  yyvsp[0].ttype,
+				  yyvsp[-7].ttype); ;
+    break;}
+case 166:
+#line 961 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 167:
+#line 963 "c-parse.y"
+{ yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyvsp[-5].ttype); ;
+    break;}
+case 168:
+#line 965 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 169:
+#line 967 "c-parse.y"
+{ yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
+    break;}
+case 170:
+#line 972 "c-parse.y"
+{ push_c_function_context ();
+		  if (! start_function (current_declspecs, yyvsp[0].ttype, 1))
+		    {
+		      pop_c_function_context ();
+		      YYERROR1;
+		    }
+		  reinit_parse_for_function ();
+		  store_parm_decls (); ;
+    break;}
+case 171:
+#line 987 "c-parse.y"
+{ finish_function (1);
+		  pop_c_function_context (); ;
+    break;}
+case 172:
+#line 993 "c-parse.y"
+{ push_c_function_context ();
+		  if (! start_function (current_declspecs, yyvsp[0].ttype, 1))
+		    {
+		      pop_c_function_context ();
+		      YYERROR1;
+		    }
+		  reinit_parse_for_function ();
+		  store_parm_decls (); ;
+    break;}
+case 173:
+#line 1008 "c-parse.y"
+{ finish_function (1);
+		  pop_c_function_context (); ;
+    break;}
+case 176:
+#line 1024 "c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+    break;}
+case 177:
+#line 1026 "c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 178:
+#line 1031 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 179:
+#line 1033 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+    break;}
+case 180:
+#line 1035 "c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 182:
+#line 1046 "c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 183:
+#line 1051 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 184:
+#line 1053 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+    break;}
+case 185:
+#line 1055 "c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 187:
+#line 1064 "c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 188:
+#line 1069 "c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+    break;}
+case 189:
+#line 1071 "c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 190:
+#line 1073 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 191:
+#line 1075 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+    break;}
+case 193:
+#line 1081 "c-parse.y"
+{ yyval.ttype = start_struct (RECORD_TYPE, yyvsp[-1].ttype);
+		  /* Start scope of tag before parsing components.  */
+		;
+    break;}
+case 194:
+#line 1085 "c-parse.y"
+{ yyval.ttype = finish_struct (yyvsp[-2].ttype, yyvsp[-1].ttype);
+		  /* Really define the structure.  */
+		;
+    break;}
+case 195:
+#line 1089 "c-parse.y"
+{ yyval.ttype = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
+				      yyvsp[-1].ttype); ;
+    break;}
+case 196:
+#line 1092 "c-parse.y"
+{ yyval.ttype = xref_tag (RECORD_TYPE, yyvsp[0].ttype); ;
+    break;}
+case 197:
+#line 1094 "c-parse.y"
+{ yyval.ttype = start_struct (UNION_TYPE, yyvsp[-1].ttype); ;
+    break;}
+case 198:
+#line 1096 "c-parse.y"
+{ yyval.ttype = finish_struct (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 199:
+#line 1098 "c-parse.y"
+{ yyval.ttype = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
+				      yyvsp[-1].ttype); ;
+    break;}
+case 200:
+#line 1101 "c-parse.y"
+{ yyval.ttype = xref_tag (UNION_TYPE, yyvsp[0].ttype); ;
+    break;}
+case 201:
+#line 1103 "c-parse.y"
+{ yyvsp[0].itype = suspend_momentary ();
+		  yyval.ttype = start_enum (yyvsp[-1].ttype); ;
+    break;}
+case 202:
+#line 1106 "c-parse.y"
+{ yyval.ttype = finish_enum (yyvsp[-3].ttype, nreverse (yyvsp[-2].ttype));
+		  resume_momentary (yyvsp[-4].itype); ;
+    break;}
+case 203:
+#line 1109 "c-parse.y"
+{ yyvsp[0].itype = suspend_momentary ();
+		  yyval.ttype = start_enum (NULL_TREE); ;
+    break;}
+case 204:
+#line 1112 "c-parse.y"
+{ yyval.ttype = finish_enum (yyvsp[-3].ttype, nreverse (yyvsp[-2].ttype));
+		  resume_momentary (yyvsp[-4].itype); ;
+    break;}
+case 205:
+#line 1115 "c-parse.y"
+{ yyval.ttype = xref_tag (ENUMERAL_TYPE, yyvsp[0].ttype); ;
+    break;}
+case 209:
+#line 1126 "c-parse.y"
+{ if (pedantic) pedwarn ("comma at end of enumerator list"); ;
+    break;}
+case 210:
+#line 1131 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype; ;
+    break;}
+case 211:
+#line 1133 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype);
+		  pedwarn ("no semicolon at end of struct or union"); ;
+    break;}
+case 212:
+#line 1138 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 213:
+#line 1140 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 214:
+#line 1142 "c-parse.y"
+{ if (pedantic)
+		    pedwarn ("extra semicolon in struct or union specified"); ;
+    break;}
+case 215:
+#line 1157 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+		  current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-1].itype); ;
+    break;}
+case 216:
+#line 1162 "c-parse.y"
+{ if (pedantic)
+		    pedwarn ("ANSI C forbids member declarations with no members");
+		  shadow_tag(yyvsp[0].ttype);
+		  yyval.ttype = NULL_TREE; ;
+    break;}
+case 217:
+#line 1167 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+		  current_declspecs = TREE_VALUE (declspec_stack);
+		  declspec_stack = TREE_CHAIN (declspec_stack);
+		  resume_momentary (yyvsp[-1].itype); ;
+    break;}
+case 218:
+#line 1172 "c-parse.y"
+{ if (pedantic)
+		    pedwarn ("ANSI C forbids member declarations with no members");
+		  shadow_tag(yyvsp[0].ttype);
+		  yyval.ttype = NULL_TREE; ;
+    break;}
+case 219:
+#line 1177 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 221:
+#line 1183 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 222:
+#line 1188 "c-parse.y"
+{ yyval.ttype = grokfield (yyvsp[-3].filename, yyvsp[-2].lineno, yyvsp[-1].ttype, current_declspecs, NULL_TREE);
+		  decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
+    break;}
+case 223:
+#line 1192 "c-parse.y"
+{ yyval.ttype = grokfield (yyvsp[-5].filename, yyvsp[-4].lineno, yyvsp[-3].ttype, current_declspecs, yyvsp[-1].ttype);
+		  decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
+    break;}
+case 224:
+#line 1195 "c-parse.y"
+{ yyval.ttype = grokfield (yyvsp[-4].filename, yyvsp[-3].lineno, NULL_TREE, current_declspecs, yyvsp[-1].ttype);
+		  decl_attributes (yyval.ttype, yyvsp[0].ttype); ;
+    break;}
+case 226:
+#line 1207 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); ;
+    break;}
+case 227:
+#line 1213 "c-parse.y"
+{ yyval.ttype = build_enumerator (yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 228:
+#line 1215 "c-parse.y"
+{ yyval.ttype = build_enumerator (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 229:
+#line 1220 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 230:
+#line 1222 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 231:
+#line 1227 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 233:
+#line 1233 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 234:
+#line 1235 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 235:
+#line 1240 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 236:
+#line 1242 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 237:
+#line 1247 "c-parse.y"
+{ yyval.ttype = yyvsp[-1].ttype; ;
+    break;}
+case 238:
+#line 1250 "c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 239:
+#line 1252 "c-parse.y"
+{ yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 240:
+#line 1254 "c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 241:
+#line 1256 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 242:
+#line 1258 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
+    break;}
+case 243:
+#line 1260 "c-parse.y"
+{ yyval.ttype = build_nt (CALL_EXPR, NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
+    break;}
+case 244:
+#line 1262 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ;
+    break;}
+case 245:
+#line 1264 "c-parse.y"
+{ yyval.ttype = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); ;
+    break;}
+case 252:
+#line 1286 "c-parse.y"
+{ emit_line_note (input_filename, lineno);
+		  pushlevel (0);
+		  clear_last_expr ();
+		  push_momentary ();
+		  expand_start_bindings (0);
+		;
+    break;}
+case 254:
+#line 1299 "c-parse.y"
+{ if (pedantic)
+		    pedwarn ("ANSI C forbids label declarations"); ;
+    break;}
+case 257:
+#line 1310 "c-parse.y"
+{ tree link;
+		  for (link = yyvsp[-1].ttype; link; link = TREE_CHAIN (link))
+		    {
+		      tree label = shadow_label (TREE_VALUE (link));
+		      C_DECLARED_LABEL_FLAG (label) = 1;
+		      declare_nonlocal_label (label);
+		    }
+		;
+    break;}
+case 258:
+#line 1324 "c-parse.y"
+{;
+    break;}
+case 260:
+#line 1329 "c-parse.y"
+{ yyval.ttype = convert (void_type_node, integer_zero_node); ;
+    break;}
+case 261:
+#line 1331 "c-parse.y"
+{ emit_line_note (input_filename, lineno);
+		  expand_end_bindings (getdecls (), 1, 0);
+		  yyval.ttype = poplevel (1, 1, 0);
+		  pop_momentary (); ;
+    break;}
+case 262:
+#line 1336 "c-parse.y"
+{ emit_line_note (input_filename, lineno);
+		  expand_end_bindings (getdecls (), kept_level_p (), 0);
+		  yyval.ttype = poplevel (kept_level_p (), 0, 0);
+		  pop_momentary (); ;
+    break;}
+case 263:
+#line 1341 "c-parse.y"
+{ emit_line_note (input_filename, lineno);
+		  expand_end_bindings (getdecls (), kept_level_p (), 0);
+		  yyval.ttype = poplevel (kept_level_p (), 0, 0);
+		  pop_momentary (); ;
+    break;}
+case 266:
+#line 1358 "c-parse.y"
+{ emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
+		  expand_start_cond (truthvalue_conversion (yyvsp[-1].ttype), 0);
+		  yyvsp[-3].itype = stmt_count;
+		  if_stmt_file = yyvsp[-5].filename;
+		  if_stmt_line = yyvsp[-4].lineno;
+		  position_after_white_space (); ;
+    break;}
+case 267:
+#line 1371 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-2].filename, yyvsp[-1].lineno);
+		  /* See comment in `while' alternative, above.  */
+		  emit_nop ();
+		  expand_start_loop_continue_elsewhere (1);
+		  position_after_white_space (); ;
+    break;}
+case 268:
+#line 1378 "c-parse.y"
+{ expand_loop_continue_here (); ;
+    break;}
+case 269:
+#line 1382 "c-parse.y"
+{ yyval.filename = input_filename; ;
+    break;}
+case 270:
+#line 1386 "c-parse.y"
+{ yyval.lineno = lineno; ;
+    break;}
+case 271:
+#line 1391 "c-parse.y"
+{ ;
+    break;}
+case 272:
+#line 1396 "c-parse.y"
+{ ;
+    break;}
+case 273:
+#line 1401 "c-parse.y"
+{ ;
+    break;}
+case 275:
+#line 1407 "c-parse.y"
+{ int next;
+		  position_after_white_space ();
+		  next = getc (finput);
+		  ungetc (next, finput);
+		  if (pedantic && next == '}')
+		    pedwarn ("ANSI C forbids label at end of compound statement");
+		;
+    break;}
+case 276:
+#line 1419 "c-parse.y"
+{ stmt_count++; ;
+    break;}
+case 278:
+#line 1422 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
+		  iterator_expand (yyvsp[-1].ttype);
+		  clear_momentary (); ;
+    break;}
+case 279:
+#line 1427 "c-parse.y"
+{ expand_start_else ();
+		  yyvsp[-1].itype = stmt_count;
+		  position_after_white_space (); ;
+    break;}
+case 280:
+#line 1431 "c-parse.y"
+{ expand_end_cond ();
+		  if (extra_warnings && stmt_count == yyvsp[-3].itype)
+		    warning ("empty body in an else-statement"); ;
+    break;}
+case 281:
+#line 1435 "c-parse.y"
+{ expand_end_cond ();
+		  if (extra_warnings && stmt_count == yyvsp[0].itype)
+		    warning_with_file_and_line (if_stmt_file, if_stmt_line,
+						"empty body in an if-statement"); ;
+    break;}
+case 282:
+#line 1443 "c-parse.y"
+{ expand_end_cond (); ;
+    break;}
+case 283:
+#line 1445 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-2].filename, yyvsp[-1].lineno);
+		  /* The emit_nop used to come before emit_line_note,
+		     but that made the nop seem like part of the preceding line.
+		     And that was confusing when the preceding line was
+		     inside of an if statement and was not really executed.
+		     I think it ought to work to put the nop after the line number.
+		     We will see.  --rms, July 15, 1991.  */
+		  emit_nop (); ;
+    break;}
+case 284:
+#line 1455 "c-parse.y"
+{ /* Don't start the loop till we have succeeded
+		     in parsing the end test.  This is to make sure
+		     that we end every loop we start.  */
+		  expand_start_loop (1);
+		  emit_line_note (input_filename, lineno);
+		  expand_exit_loop_if_false (NULL_PTR,
+					     truthvalue_conversion (yyvsp[-1].ttype));
+		  position_after_white_space (); ;
+    break;}
+case 285:
+#line 1464 "c-parse.y"
+{ expand_end_loop (); ;
+    break;}
+case 286:
+#line 1467 "c-parse.y"
+{ emit_line_note (input_filename, lineno);
+		  expand_exit_loop_if_false (NULL_PTR,
+					     truthvalue_conversion (yyvsp[-2].ttype));
+		  expand_end_loop ();
+		  clear_momentary (); ;
+    break;}
+case 287:
+#line 1474 "c-parse.y"
+{ expand_end_loop ();
+		  clear_momentary (); ;
+    break;}
+case 288:
+#line 1478 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
+		  /* See comment in `while' alternative, above.  */
+		  emit_nop ();
+		  if (yyvsp[-1].ttype) c_expand_expr_stmt (yyvsp[-1].ttype);
+		  /* Next step is to call expand_start_loop_continue_elsewhere,
+		     but wait till after we parse the entire for (...).
+		     Otherwise, invalid input might cause us to call that
+		     fn without calling expand_end_loop.  */
+		;
+    break;}
+case 289:
+#line 1490 "c-parse.y"
+{ yyvsp[0].lineno = lineno;
+		  yyval.filename = input_filename; ;
+    break;}
+case 290:
+#line 1493 "c-parse.y"
+{ 
+		  /* Start the loop.  Doing this after parsing
+		     all the expressions ensures we will end the loop.  */
+		  expand_start_loop_continue_elsewhere (1);
+		  /* Emit the end-test, with a line number.  */
+		  emit_line_note (yyvsp[-2].filename, yyvsp[-3].lineno);
+		  if (yyvsp[-4].ttype)
+		    expand_exit_loop_if_false (NULL_PTR,
+					       truthvalue_conversion (yyvsp[-4].ttype));
+		  /* Don't let the tree nodes for $9 be discarded by
+		     clear_momentary during the parsing of the next stmt.  */
+		  push_momentary ();
+		  yyvsp[-3].lineno = lineno;
+		  yyvsp[-2].filename = input_filename;
+		  position_after_white_space (); ;
+    break;}
+case 291:
+#line 1509 "c-parse.y"
+{ /* Emit the increment expression, with a line number.  */
+		  emit_line_note (yyvsp[-4].filename, yyvsp[-5].lineno);
+		  expand_loop_continue_here ();
+		  if (yyvsp[-3].ttype)
+		    c_expand_expr_stmt (yyvsp[-3].ttype);
+		  pop_momentary ();
+		  expand_end_loop (); ;
+    break;}
+case 292:
+#line 1517 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
+		  c_expand_start_case (yyvsp[-1].ttype);
+		  /* Don't let the tree nodes for $3 be discarded by
+		     clear_momentary during the parsing of the next stmt.  */
+		  push_momentary ();
+		  position_after_white_space (); ;
+    break;}
+case 293:
+#line 1525 "c-parse.y"
+{ expand_end_case (yyvsp[-3].ttype);
+		  pop_momentary (); ;
+    break;}
+case 294:
+#line 1528 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
+		  if ( ! expand_exit_something ())
+		    error ("break statement not within loop or switch"); ;
+    break;}
+case 295:
+#line 1533 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
+		  if (! expand_continue_loop (NULL_PTR))
+		    error ("continue statement not within a loop"); ;
+    break;}
+case 296:
+#line 1538 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
+		  c_expand_return (NULL_TREE); ;
+    break;}
+case 297:
+#line 1542 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-4].filename, yyvsp[-3].lineno);
+		  c_expand_return (yyvsp[-1].ttype); ;
+    break;}
+case 298:
+#line 1546 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-7].filename, yyvsp[-6].lineno);
+		  STRIP_NOPS (yyvsp[-2].ttype);
+		  if ((TREE_CODE (yyvsp[-2].ttype) == ADDR_EXPR
+		       && TREE_CODE (TREE_OPERAND (yyvsp[-2].ttype, 0)) == STRING_CST)
+		      || TREE_CODE (yyvsp[-2].ttype) == STRING_CST)
+		    expand_asm (yyvsp[-2].ttype);
+		  else
+		    error ("argument of `asm' is not a constant string"); ;
+    break;}
+case 299:
+#line 1557 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-9].filename, yyvsp[-8].lineno);
+		  c_expand_asm_operands (yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE, NULL_TREE,
+					 yyvsp[-6].ttype == ridpointers[(int)RID_VOLATILE],
+					 input_filename, lineno); ;
+    break;}
+case 300:
+#line 1564 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-11].filename, yyvsp[-10].lineno);
+		  c_expand_asm_operands (yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE,
+					 yyvsp[-8].ttype == ridpointers[(int)RID_VOLATILE],
+					 input_filename, lineno); ;
+    break;}
+case 301:
+#line 1572 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-13].filename, yyvsp[-12].lineno);
+		  c_expand_asm_operands (yyvsp[-8].ttype, yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype,
+					 yyvsp[-10].ttype == ridpointers[(int)RID_VOLATILE],
+					 input_filename, lineno); ;
+    break;}
+case 302:
+#line 1578 "c-parse.y"
+{ tree decl;
+		  stmt_count++;
+		  emit_line_note (yyvsp[-4].filename, yyvsp[-3].lineno);
+		  decl = lookup_label (yyvsp[-1].ttype);
+		  if (decl != 0)
+		    {
+		      TREE_USED (decl) = 1;
+		      expand_goto (decl);
+		    }
+		;
+    break;}
+case 303:
+#line 1589 "c-parse.y"
+{ stmt_count++;
+		  emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
+		  expand_computed_goto (convert (ptr_type_node, yyvsp[-1].ttype)); ;
+    break;}
+case 306:
+#line 1602 "c-parse.y"
+{
+	    /* The value returned by this action is  */
+	    /*      1 if everything is OK */ 
+	    /*      0 in case of error or already bound iterator */
+
+	    yyval.itype = 0;
+	    if (TREE_CODE (yyvsp[-1].ttype) != VAR_DECL)
+	      error ("invalid `for (ITERATOR)' syntax");
+	    if (! ITERATOR_P (yyvsp[-1].ttype))
+	      error ("`%s' is not an iterator",
+		     IDENTIFIER_POINTER (DECL_NAME (yyvsp[-1].ttype)));
+	    else if (ITERATOR_BOUND_P (yyvsp[-1].ttype))
+	      error ("`for (%s)' inside expansion of same iterator",
+		     IDENTIFIER_POINTER (DECL_NAME (yyvsp[-1].ttype)));
+	    else
+	      {
+		yyval.itype = 1;
+		iterator_for_loop_start (yyvsp[-1].ttype);
+	      }
+	  ;
+    break;}
+case 307:
+#line 1623 "c-parse.y"
+{
+	    if (yyvsp[-1].itype)
+	      iterator_for_loop_end (yyvsp[-3].ttype);
+	  ;
+    break;}
+case 308:
+#line 1655 "c-parse.y"
+{ register tree value = check_case_value (yyvsp[-1].ttype);
+		  register tree label
+		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+
+		  stmt_count++;
+
+		  if (value != error_mark_node)
+		    {
+		      tree duplicate;
+		      int success = pushcase (value, label, &duplicate);
+		      if (success == 1)
+			error ("case label not within a switch statement");
+		      else if (success == 2)
+			{
+			  error ("duplicate case value");
+			  error_with_decl (duplicate, "this is the first entry for that value");
+			}
+		      else if (success == 3)
+			warning ("case value out of range");
+		      else if (success == 5)
+			error ("case label within scope of cleanup or variable array");
+		    }
+		  position_after_white_space (); ;
+    break;}
+case 309:
+#line 1679 "c-parse.y"
+{ register tree value1 = check_case_value (yyvsp[-3].ttype);
+		  register tree value2 = check_case_value (yyvsp[-1].ttype);
+		  register tree label
+		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+
+		  stmt_count++;
+
+		  if (value1 != error_mark_node && value2 != error_mark_node)
+		    {
+		      tree duplicate;
+		      int success = pushcase_range (value1, value2, label,
+						    &duplicate);
+		      if (success == 1)
+			error ("case label not within a switch statement");
+		      else if (success == 2)
+			{
+			  error ("duplicate case value");
+			  error_with_decl (duplicate, "this is the first entry for that value");
+			}
+		      else if (success == 3)
+			warning ("case value out of range");
+		      else if (success == 4)
+			warning ("empty case range");
+		      else if (success == 5)
+			error ("case label within scope of cleanup or variable array");
+		    }
+		  position_after_white_space (); ;
+    break;}
+case 310:
+#line 1707 "c-parse.y"
+{
+		  tree duplicate;
+		  register tree label
+		    = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+		  int success = pushcase (NULL_TREE, label, &duplicate);
+		  stmt_count++;
+		  if (success == 1)
+		    error ("default label not within a switch statement");
+		  else if (success == 2)
+		    {
+		      error ("multiple default labels in one switch");
+		      error_with_decl (duplicate, "this is the first default label");
+		    }
+		  position_after_white_space (); ;
+    break;}
+case 311:
+#line 1722 "c-parse.y"
+{ tree label = define_label (input_filename, lineno, yyvsp[-1].ttype);
+		  stmt_count++;
+		  emit_nop ();
+		  if (label)
+		    expand_label (label);
+		  position_after_white_space (); ;
+    break;}
+case 312:
+#line 1734 "c-parse.y"
+{ emit_line_note (input_filename, lineno); ;
+    break;}
+case 313:
+#line 1736 "c-parse.y"
+{ emit_line_note (input_filename, lineno); ;
+    break;}
+case 314:
+#line 1741 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 316:
+#line 1748 "c-parse.y"
+{ yyval.ttype = NULL_TREE; ;
+    break;}
+case 319:
+#line 1755 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
+    break;}
+case 320:
+#line 1760 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
+    break;}
+case 321:
+#line 1765 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, combine_strings (yyvsp[0].ttype), NULL_TREE); ;
+    break;}
+case 322:
+#line 1767 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, combine_strings (yyvsp[0].ttype), yyvsp[-2].ttype); ;
+    break;}
+case 323:
+#line 1773 "c-parse.y"
+{ pushlevel (0);
+		  clear_parm_order ();
+		  declare_parm_level (0); ;
+    break;}
+case 324:
+#line 1777 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+		  parmlist_tags_warning ();
+		  poplevel (0, 0, 0); ;
+    break;}
+case 326:
+#line 1785 "c-parse.y"
+{ tree parm;
+		  if (pedantic)
+		    pedwarn ("ANSI C forbids forward parameter declarations");
+		  /* Mark the forward decls as such.  */
+		  for (parm = getdecls (); parm; parm = TREE_CHAIN (parm))
+		    TREE_ASM_WRITTEN (parm) = 1;
+		  clear_parm_order (); ;
+    break;}
+case 327:
+#line 1793 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype; ;
+    break;}
+case 328:
+#line 1795 "c-parse.y"
+{ yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); ;
+    break;}
+case 329:
+#line 1801 "c-parse.y"
+{ yyval.ttype = get_parm_info (0); ;
+    break;}
+case 330:
+#line 1803 "c-parse.y"
+{ yyval.ttype = get_parm_info (0);
+		  if (pedantic)
+		    pedwarn ("ANSI C requires a named argument before `...'");
+		;
+    break;}
+case 331:
+#line 1808 "c-parse.y"
+{ yyval.ttype = get_parm_info (1); ;
+    break;}
+case 332:
+#line 1810 "c-parse.y"
+{ yyval.ttype = get_parm_info (0); ;
+    break;}
+case 333:
+#line 1815 "c-parse.y"
+{ push_parm_decl (yyvsp[0].ttype); ;
+    break;}
+case 334:
+#line 1817 "c-parse.y"
+{ push_parm_decl (yyvsp[0].ttype); ;
+    break;}
+case 335:
+#line 1824 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype)	; ;
+    break;}
+case 336:
+#line 1826 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype)	; ;
+    break;}
+case 337:
+#line 1828 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 338:
+#line 1830 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype)	; ;
+    break;}
+case 339:
+#line 1832 "c-parse.y"
+{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
+    break;}
+case 340:
+#line 1839 "c-parse.y"
+{ pushlevel (0);
+		  clear_parm_order ();
+		  declare_parm_level (1); ;
+    break;}
+case 341:
+#line 1843 "c-parse.y"
+{ yyval.ttype = yyvsp[0].ttype;
+		  parmlist_tags_warning ();
+		  poplevel (0, 0, 0); ;
+    break;}
+case 343:
+#line 1851 "c-parse.y"
+{ tree t;
+		  for (t = yyvsp[-1].ttype; t; t = TREE_CHAIN (t))
+		    if (TREE_VALUE (t) == NULL_TREE)
+		      error ("`...' in old-style identifier list");
+		  yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, yyvsp[-1].ttype); ;
+    break;}
+case 344:
+#line 1861 "c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+    break;}
+case 345:
+#line 1863 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
+    break;}
+case 346:
+#line 1869 "c-parse.y"
+{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
+    break;}
+case 347:
+#line 1871 "c-parse.y"
+{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+#line 440 "bison.simple"
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+  yylsp++;
+  if (yylen == 0)
+    {
+      yylsp->first_line = yylloc.first_line;
+      yylsp->first_column = yylloc.first_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
+      yylsp->text = 0;
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
+#endif
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yyerrlab:   /* here on detecting error */
+
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (yyn > YYFLAG && yyn < YYLAST)
+	{
+	  int size = 0;
+	  char *msg;
+	  int x, count;
+
+	  count = 0;
+	  for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+	    if (yycheck[x + yyn] == x)
+	      size += strlen(yytname[x]) + 15, count++;
+	  msg = (char *) malloc(size + 15);
+	  if (msg != 0)
+	    {
+	      strcpy(msg, "parse error");
+
+	      if (count < 5)
+		{
+		  count = 0;
+		  for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
+		    if (yycheck[x + yyn] == x)
+		      {
+			strcat(msg, count == 0 ? ", expecting `" : " or `");
+			strcat(msg, yytname[x]);
+			strcat(msg, "'");
+			count++;
+		      }
+		}
+	      yyerror(msg);
+	      free(msg);
+	    }
+	  else
+	    yyerror ("parse error; also virtual memory exceeded");
+	}
+      else
+#endif /* YYERROR_VERBOSE */
+	yyerror("parse error");
+    }
+
+yyerrlab1:   /* here on error raised explicitly by an action */
+
+  if (yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+	YYABORT;
+
+#if YYDEBUG != 0
+      if (yydebug)
+	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+      yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+  yyerrstatus = 3;		/* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
+
+yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != yyssp)
+	fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+	goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  yystate = yyn;
+  goto yynewstate;
+}
+#line 1874 "c-parse.y"
+
diff --git a/gnu/usr.bin/cc/cc1/c-pragma.c b/gnu/usr.bin/cc/cc1/c-pragma.c
new file mode 100644
index 000000000000..9bb92661d2ba
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-pragma.c
@@ -0,0 +1,198 @@
+/* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
+   Copyright (C) 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <stdio.h>
+#include "config.h"
+#include "tree.h"
+
+#ifdef HANDLE_SYSV_PRAGMA
+
+/* Support #pragma weak by default if WEAK_ASM_OP is defined.  */
+#if !defined (HANDLE_PRAGMA_WEAK) && defined (WEAK_ASM_OP) && defined (SET_ASM_OP)
+#define HANDLE_PRAGMA_WEAK 1
+#endif
+
+/* When structure field packing is in effect, this variable is the
+   number of bits to use as the maximum alignment.  When packing is not
+   in effect, this is zero. */
+
+extern int maximum_field_alignment;
+
+/* File used for outputting assembler code.  */
+extern FILE *asm_out_file;
+
+/* Handle one token of a pragma directive.  TOKEN is the
+   current token, and STRING is its printable form.  */
+
+void
+handle_pragma_token (string, token)
+     char *string;
+     tree token;
+{
+  static enum pragma_state
+    {
+      ps_start,
+      ps_done,
+      ps_bad,
+      ps_weak,
+      ps_name,
+      ps_equals,
+      ps_value,
+      ps_pack,
+      ps_left,
+      ps_align,
+      ps_right
+      } state = ps_start, type;
+  static char *name;
+  static char *value;
+  static int align;
+
+  if (string == 0)
+    {
+      if (type == ps_pack)
+	{
+	  if (state == ps_right)
+	    maximum_field_alignment = align * 8;
+	  else
+	    warning ("malformed `#pragma pack'");
+	}
+      else if (type == ps_weak)
+	{
+#ifdef HANDLE_PRAGMA_WEAK
+	  if (HANDLE_PRAGMA_WEAK)
+	    {
+	      if (state == ps_name || state == ps_value)
+		{
+		  fprintf (asm_out_file, "\t%s\t", WEAK_ASM_OP);
+		  ASM_OUTPUT_LABELREF (asm_out_file, name);
+		  fputc ('\n', asm_out_file);
+		  if (state == ps_value)
+		    {
+		      fprintf (asm_out_file, "\t%s\t", SET_ASM_OP);
+		      ASM_OUTPUT_LABELREF (asm_out_file, name);
+		      fputc (',', asm_out_file);
+		      ASM_OUTPUT_LABELREF (asm_out_file, value);
+		      fputc ('\n', asm_out_file);
+		    }
+		}
+	      else if (! (state == ps_done || state == ps_start))
+		warning ("malformed `#pragma weak'");
+	    }
+#endif /* HANDLE_PRAMA_WEAK */
+	}
+
+      type = state = ps_start;
+      return;
+    }
+
+  switch (state)
+    {
+    case ps_start:
+      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+	{
+	  if (strcmp (IDENTIFIER_POINTER (token), "pack") == 0)
+	    type = state = ps_pack;
+	  else if (strcmp (IDENTIFIER_POINTER (token), "weak") == 0)
+	    type = state = ps_weak;
+	  else
+	    type = state = ps_done;
+	}
+      else
+	type = state = ps_done;
+      break;
+
+    case ps_weak:
+      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+	{
+	  name = IDENTIFIER_POINTER (token);
+	  state = ps_name;
+	}
+      else
+	state = ps_bad;
+      break;
+
+    case ps_name:
+      state = (strcmp (string, "=") ? ps_bad : ps_equals);
+      break;
+
+    case ps_equals:
+      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+	{
+	  value = IDENTIFIER_POINTER (token);
+	  state = ps_value;
+	}
+      else
+	state = ps_bad;
+      break;
+
+    case ps_value:
+      state = ps_bad;
+      break;
+
+    case ps_pack:
+      if (strcmp (string, "(") == 0)
+	state = ps_left;
+      else
+	state = ps_bad;
+      break;
+
+    case ps_left:
+      if (token && TREE_CODE (token) == INTEGER_CST
+	  && TREE_INT_CST_HIGH (token) == 0)
+	switch (TREE_INT_CST_LOW (token))
+	  {
+	  case 1:
+	  case 2:
+	  case 4:
+	    align = TREE_INT_CST_LOW (token);
+	    state = ps_align;
+	    break;
+
+	  default:
+	    state = ps_bad;
+	  }
+      else if (! token && strcmp (string, ")") == 0)
+	{
+	  align = 0;
+	  state = ps_right;
+	}
+      else
+	state = ps_bad;
+      break;
+
+    case ps_align:
+      if (strcmp (string, ")") == 0)
+	state = ps_right;
+      else
+	state = ps_bad;
+      break;
+
+    case ps_right:
+      state = ps_bad;
+      break;
+
+    case ps_bad:
+    case ps_done:
+      break;
+
+    default:
+      abort ();
+    }
+}
+#endif /* HANDLE_SYSV_PRAGMA */
diff --git a/gnu/usr.bin/cc/cc1/c-typeck.c b/gnu/usr.bin/cc/cc1/c-typeck.c
new file mode 100644
index 000000000000..a10fb0abcc3f
--- /dev/null
+++ b/gnu/usr.bin/cc/cc1/c-typeck.c
@@ -0,0 +1,5827 @@
+/* Build expressions with type checking for C compiler.
+   Copyright (C) 1987, 1988, 1989, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* This file is part of the C front end.
+   It contains routines to build C expressions given their operands,
+   including computing the types of the result, C-specific error checks,
+   and some optimization.
+
+   There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
+   and to process initializations in declarations (since they work
+   like a strange sort of assignment).  */
+
+#include "config.h"
+#include <stdio.h>
+#include "tree.h"
+#include "c-tree.h"
+#include "flags.h"
+
+/* Nonzero if we've already printed a "partly bracketed initializer"
+   message within this initializer.  */
+static int partial_bracket_mentioned = 0;
+
+extern char *index ();
+extern char *rindex ();
+
+int mark_addressable ();
+static tree convert_for_assignment ();
+static void warn_for_assignment ();
+static int function_types_compatible_p ();
+static int type_lists_compatible_p ();
+int self_promoting_args_p ();
+static int self_promoting_type_p ();
+static int comp_target_types ();
+static tree pointer_int_sum ();
+static tree pointer_diff ();
+static tree convert_sequence ();
+static tree unary_complex_lvalue ();
+static tree process_init_constructor ();
+static tree convert_arguments ();
+static char *get_spelling ();
+tree digest_init ();
+static void pedantic_lvalue_warning ();
+tree truthvalue_conversion ();
+void incomplete_type_error ();
+void readonly_warning ();
+static tree internal_build_compound_expr ();
+
+
+/* Do `exp = require_complete_type (exp);' to make sure exp
+   does not have an incomplete type.  (That includes void types.)  */
+
+tree
+require_complete_type (value)
+     tree value;
+{
+  tree type = TREE_TYPE (value);
+
+  /* First, detect a valid value with a complete type.  */
+  if (TYPE_SIZE (type) != 0
+      && type != void_type_node)
+    return value;
+
+  incomplete_type_error (value, type);
+  return error_mark_node;
+}
+
+/* Print an error message for invalid use of an incomplete type.
+   VALUE is the expression that was used (or 0 if that isn't known)
+   and TYPE is the type that was invalid.  */
+
+void
+incomplete_type_error (value, type)
+     tree value;
+     tree type;
+{
+  char *errmsg;
+
+  /* Avoid duplicate error message.  */
+  if (TREE_CODE (type) == ERROR_MARK)
+    return;
+
+  if (value != 0 && (TREE_CODE (value) == VAR_DECL
+		     || TREE_CODE (value) == PARM_DECL))
+    error ("`%s' has an incomplete type",
+	   IDENTIFIER_POINTER (DECL_NAME (value)));
+  else
+    {
+    retry:
+      /* We must print an error message.  Be clever about what it says.  */
+
+      switch (TREE_CODE (type))
+	{
+	case RECORD_TYPE:
+	  errmsg = "invalid use of undefined type `struct %s'";
+	  break;
+
+	case UNION_TYPE:
+	  errmsg = "invalid use of undefined type `union %s'";
+	  break;
+
+	case ENUMERAL_TYPE:
+	  errmsg = "invalid use of undefined type `enum %s'";
+	  break;
+
+	case VOID_TYPE:
+	  error ("invalid use of void expression");
+	  return;
+
+	case ARRAY_TYPE:
+	  if (TYPE_DOMAIN (type))
+	    {
+	      type = TREE_TYPE (type);
+	      goto retry;
+	    }
+	  error ("invalid use of array with unspecified bounds");
+	  return;
+
+	default:
+	  abort ();
+	}
+
+      if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
+	error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
+      else
+	/* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
+	error ("invalid use of incomplete typedef `%s'",
+	       IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
+    }
+}
+
+/* Return a variant of TYPE which has all the type qualifiers of LIKE
+   as well as those of TYPE.  */
+
+static tree
+qualify_type (type, like)
+     tree type, like;
+{
+  int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
+  int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
+  return c_build_type_variant (type, constflag, volflag);
+}
+
+/* Return the common type of two types.
+   We assume that comptypes has already been done and returned 1;
+   if that isn't so, this may crash.  In particular, we assume that qualifiers
+   match.
+
+   This is the type for the result of most arithmetic operations
+   if the operands have the given two types.  */
+
+tree
+common_type (t1, t2)
+     tree t1, t2;
+{
+  register enum tree_code code1;
+  register enum tree_code code2;
+
+  /* Save time if the two types are the same.  */
+
+  if (t1 == t2) return t1;
+
+  /* If one type is nonsense, use the other.  */
+  if (t1 == error_mark_node)
+    return t2;
+  if (t2 == error_mark_node)
+    return t1;
+
+  /* Treat an enum type as the unsigned integer type of the same width.  */
+
+  if (TREE_CODE (t1) == ENUMERAL_TYPE)
+    t1 = type_for_size (TYPE_PRECISION (t1), 1);
+  if (TREE_CODE (t2) == ENUMERAL_TYPE)
+    t2 = type_for_size (TYPE_PRECISION (t2), 1);
+
+  code1 = TREE_CODE (t1);
+  code2 = TREE_CODE (t2);
+
+  /* If one type is complex, form the common type
+     of the non-complex components,
+     then make that complex.  */
+  if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
+    {
+      tree subtype1, subtype2, subtype;
+      if (code1 == COMPLEX_TYPE)
+	subtype1 = TREE_TYPE (t1);
+      else
+	subtype1 = t1;
+      if (code2 == COMPLEX_TYPE)
+	subtype2 = TREE_TYPE (t2);
+      else
+	subtype2 = t2;
+      subtype = common_type (subtype1, subtype2);
+      return build_complex_type (subtype);
+    }
+
+  switch (code1)
+    {
+    case INTEGER_TYPE:
+    case REAL_TYPE:
+      /* If only one is real, use it as the result.  */
+
+      if (code1 == REAL_TYPE && code2 != REAL_TYPE)
+	return t1;
+
+      if (code2 == REAL_TYPE && code1 != REAL_TYPE)
+	return t2;
+
+      /* Both real or both integers; use the one with greater precision.  */
+
+      if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
+	return t1;
+      else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
+	return t2;
+
+      /* Same precision.  Prefer longs to ints even when same size.  */
+
+      if (t1 == long_unsigned_type_node
+	  || t2 == long_unsigned_type_node)
+	return long_unsigned_type_node;
+
+      if (t1 == long_integer_type_node
+	  || t2 == long_integer_type_node)
+	{
+	  /* But preserve unsignedness from the other type,
+	     since long cannot hold all the values of an unsigned int.  */
+	  if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
+	    return long_unsigned_type_node;
+	  return long_integer_type_node;
+	}
+
+      /* Otherwise prefer the unsigned one.  */
+
+      if (TREE_UNSIGNED (t1))
+	return t1;
+      else return t2;
+
+    case POINTER_TYPE:
+      /* For two pointers, do this recursively on the target type,
+	 and combine the qualifiers of the two types' targets.  */
+      /* This code was turned off; I don't know why.
+	 But ANSI C specifies doing this with the qualifiers.
+	 So I turned it on again.  */
+      {
+	tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
+				   TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
+	int constp
+	  = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
+	int volatilep
+	  = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
+	return build_pointer_type (c_build_type_variant (target, constp, volatilep));
+      }
+#if 0
+      return build_pointer_type (common_type (TREE_TYPE (t1), TREE_TYPE (t2)));
+#endif
+
+    case ARRAY_TYPE:
+      {
+	tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
+	/* Save space: see if the result is identical to one of the args.  */
+	if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
+	  return t1;
+	if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
+	  return t2;
+	/* Merge the element types, and have a size if either arg has one.  */
+	return build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
+      }
+
+    case FUNCTION_TYPE:
+      /* Function types: prefer the one that specified arg types.
+	 If both do, merge the arg types.  Also merge the return types.  */
+      {
+	tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
+	tree p1 = TYPE_ARG_TYPES (t1);
+	tree p2 = TYPE_ARG_TYPES (t2);
+	int len;
+	tree newargs, n;
+	int i;
+
+	/* Save space: see if the result is identical to one of the args.  */
+	if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
+	  return t1;
+	if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
+	  return t2;
+
+	/* Simple way if one arg fails to specify argument types.  */
+	if (TYPE_ARG_TYPES (t1) == 0)
+	  return build_function_type (valtype, TYPE_ARG_TYPES (t2));
+	if (TYPE_ARG_TYPES (t2) == 0)
+	  return build_function_type (valtype, TYPE_ARG_TYPES (t1));
+
+	/* If both args specify argument types, we must merge the two
+	   lists, argument by argument.  */
+
+	len = list_length (p1);
+	newargs = 0;
+
+	for (i = 0; i < len; i++)
+	  newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
+
+	n = newargs;
+
+	for (; p1;
+	     p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
+	  {
+	    /* A null type means arg type is not specified.
+	       Take whatever the other function type has.  */
+	    if (TREE_VALUE (p1) == 0)
+	      {
+		TREE_VALUE (n) = TREE_VALUE (p2);
+		goto parm_done;
+	      }
+	    if (TREE_VALUE (p2) == 0)
+	      {
+		TREE_VALUE (n) = TREE_VALUE (p1);
+		goto parm_done;
+	      }
+	      
+	    /* Given  wait (union {union wait *u; int *i} *)
+	       and  wait (union wait *),
+	       prefer  union wait *  as type of parm.  */
+	    if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
+		&& TREE_VALUE (p1) != TREE_VALUE (p2))
+	      {
+		tree memb;
+		for (memb = TYPE_FIELDS (TREE_VALUE (p1));
+		     memb; memb = TREE_CHAIN (memb))
+		  if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
+		    {
+		      TREE_VALUE (n) = TREE_VALUE (p2);
+		      if (pedantic)
+			pedwarn ("function types not truly compatible in ANSI C");
+		      goto parm_done;
+		    }
+	      }
+	    if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
+		&& TREE_VALUE (p2) != TREE_VALUE (p1))
+	      {
+		tree memb;
+		for (memb = TYPE_FIELDS (TREE_VALUE (p2));
+		     memb; memb = TREE_CHAIN (memb))
+		  if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
+		    {
+		      TREE_VALUE (n) = TREE_VALUE (p1);
+		      if (pedantic)
+			pedwarn ("function types not truly compatible in ANSI C");
+		      goto parm_done;
+		    }
+	      }
+	    TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
+	  parm_done: ;
+	  }
+
+	return build_function_type (valtype, newargs);
+      }
+
+    default:
+      return t1;
+    }
+
+}
+
+/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
+   or various other operations.  Return 2 if they are compatible
+   but a warning may be needed if you use them together.  */
+
+int
+comptypes (type1, type2)
+     tree type1, type2;
+{
+  register tree t1 = type1;
+  register tree t2 = type2;
+
+  /* Suppress errors caused by previously reported errors.  */
+
+  if (t1 == t2 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
+    return 1;
+
+  /* Treat an enum type as the unsigned integer type of the same width.  */
+
+  if (TREE_CODE (t1) == ENUMERAL_TYPE)
+    t1 = type_for_size (TYPE_PRECISION (t1), 1);
+  if (TREE_CODE (t2) == ENUMERAL_TYPE)
+    t2 = type_for_size (TYPE_PRECISION (t2), 1);
+
+  if (t1 == t2)
+    return 1;
+
+  /* Different classes of types can't be compatible.  */
+
+  if (TREE_CODE (t1) != TREE_CODE (t2)) return 0;
+
+  /* Qualifiers must match.  */
+
+  if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
+    return 0;
+  if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
+    return 0;
+
+  /* Allow for two different type nodes which have essentially the same
+     definition.  Note that we already checked for equality of the type
+     type qualifiers (just above).  */
+
+  if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
+    return 1;
+
+  switch (TREE_CODE (t1))
+    {
+    case POINTER_TYPE:
+      return (TREE_TYPE (t1) == TREE_TYPE (t2)
+	      ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
+
+    case FUNCTION_TYPE:
+      return function_types_compatible_p (t1, t2);
+
+    case ARRAY_TYPE:
+      {
+	/* 1 if no need for warning yet, 2 if warning cause has been seen.  */
+	int val = 1;
+	tree d1 = TYPE_DOMAIN (t1);
+	tree d2 = TYPE_DOMAIN (t2);
+
+	/* Target types must match incl. qualifiers.  */
+	if (TREE_TYPE (t1) != TREE_TYPE (t2)
+	    && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
+	  return 0;
+
+	/* Sizes must match unless one is missing or variable.  */
+	if (d1 == 0 || d2 == 0 || d1 == d2
+	    || TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
+	    || TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
+	    || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST
+	    || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)
+	  return val;
+
+	return (((TREE_INT_CST_LOW (TYPE_MIN_VALUE (d1))
+		  == TREE_INT_CST_LOW (TYPE_MIN_VALUE (d2)))
+		 && (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d1))
+		     == TREE_INT_CST_HIGH (TYPE_MIN_VALUE (d2)))
+		 && (TREE_INT_CST_LOW (TYPE_MAX_VALUE (d1))
+		     == TREE_INT_CST_LOW (TYPE_MAX_VALUE (d2)))
+		 && (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d1))
+		     == TREE_INT_CST_HIGH (TYPE_MAX_VALUE (d2))))
+		? val : 0);
+      }
+
+    case RECORD_TYPE:
+      if (maybe_objc_comptypes (t1, t2, 0) == 1)
+	return 1;
+    }
+  return 0;
+}
+
+/* Return 1 if TTL and TTR are pointers to types that are equivalent,
+   ignoring their qualifiers.  */
+
+static int
+comp_target_types (ttl, ttr)
+     tree ttl, ttr;
+{
+  int val;
+
+  /* Give maybe_objc_comptypes a crack at letting these types through.  */
+  if (val = maybe_objc_comptypes (ttl, ttr, 1) >= 0)
+    return val;
+
+  val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
+		   TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
+
+  if (val == 2 && pedantic)
+    pedwarn ("types are not quite compatible");
+  return val;
+}
+
+/* Subroutines of `comptypes'.  */
+
+/* Return 1 if two function types F1 and F2 are compatible.
+   If either type specifies no argument types,
+   the other must specify a fixed number of self-promoting arg types.
+   Otherwise, if one type specifies only the number of arguments, 
+   the other must specify that number of self-promoting arg types.
+   Otherwise, the argument types must match.  */
+
+static int
+function_types_compatible_p (f1, f2)
+     tree f1, f2;
+{
+  tree args1, args2;
+  /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
+  int val = 1;
+  int val1;
+
+  if (!(TREE_TYPE (f1) == TREE_TYPE (f2)
+	|| (val = comptypes (TREE_TYPE (f1), TREE_TYPE (f2)))))
+    return 0;
+
+  args1 = TYPE_ARG_TYPES (f1);
+  args2 = TYPE_ARG_TYPES (f2);
+
+  /* An unspecified parmlist matches any specified parmlist
+     whose argument types don't need default promotions.  */
+
+  if (args1 == 0)
+    {
+      if (!self_promoting_args_p (args2))
+	return 0;
+      /* If one of these types comes from a non-prototype fn definition,
+	 compare that with the other type's arglist.
+	 If they don't match, ask for a warning (but no error).  */
+      if (TYPE_ACTUAL_ARG_TYPES (f1)
+	  && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
+	val = 2;
+      return val;
+    }
+  if (args2 == 0)
+    {
+      if (!self_promoting_args_p (args1))
+	return 0;
+      if (TYPE_ACTUAL_ARG_TYPES (f2)
+	  && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
+	val = 2;
+      return val;
+    }
+
+  /* Both types have argument lists: compare them and propagate results.  */
+  val1 = type_lists_compatible_p (args1, args2);
+  return val1 != 1 ? val1 : val;
+}
+
+/* Check two lists of types for compatibility,
+   returning 0 for incompatible, 1 for compatible,
+   or 2 for compatible with warning.  */
+
+static int
+type_lists_compatible_p (args1, args2)
+     tree args1, args2;
+{
+  /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
+  int val = 1;
+  int newval;
+
+  while (1)
+    {
+      if (args1 == 0 && args2 == 0)
+	return val;
+      /* If one list is shorter than the other,
+	 they fail to match.  */
+      if (args1 == 0 || args2 == 0)
+	return 0;
+      /* A null pointer instead of a type
+	 means there is supposed to be an argument
+	 but nothing is specified about what type it has.
+	 So match anything that self-promotes.  */
+      if (TREE_VALUE (args1) == 0)
+	{
+	  if (! self_promoting_type_p (TREE_VALUE (args2)))
+	    return 0;
+	}
+      else if (TREE_VALUE (args2) == 0)
+	{
+	  if (! self_promoting_type_p (TREE_VALUE (args1)))
+	    return 0;
+	}
+      else if (! (newval = comptypes (TREE_VALUE (args1), TREE_VALUE (args2))))
+	{
+	  /* Allow  wait (union {union wait *u; int *i} *)
+	     and  wait (union wait *)  to be compatible.  */
+	  if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
+	      && TYPE_NAME (TREE_VALUE (args1)) == 0
+	      && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
+	      && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
+				     TYPE_SIZE (TREE_VALUE (args2))))
+	    {
+	      tree memb;
+	      for (memb = TYPE_FIELDS (TREE_VALUE (args1));
+		   memb; memb = TREE_CHAIN (memb))
+		if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
+		  break;
+	      if (memb == 0)
+		return 0;
+	    }
+	  else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
+		   && TYPE_NAME (TREE_VALUE (args2)) == 0
+		   && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
+		   && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
+					  TYPE_SIZE (TREE_VALUE (args1))))
+	    {
+	      tree memb;
+	      for (memb = TYPE_FIELDS (TREE_VALUE (args2));
+		   memb; memb = TREE_CHAIN (memb))
+		if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
+		  break;
+	      if (memb == 0)
+		return 0;
+	    }
+	  else
+	    return 0;
+	}
+
+      /* comptypes said ok, but record if it said to warn.  */
+      if (newval > val)
+	val = newval;
+
+      args1 = TREE_CHAIN (args1);
+      args2 = TREE_CHAIN (args2);
+    }
+}
+
+/* Return 1 if PARMS specifies a fixed number of parameters
+   and none of their types is affected by default promotions.  */
+
+int
+self_promoting_args_p (parms)
+     tree parms;
+{
+  register tree t;
+  for (t = parms; t; t = TREE_CHAIN (t))
+    {
+      register tree type = TREE_VALUE (t);
+
+      if (TREE_CHAIN (t) == 0 && type != void_type_node)
+	return 0;
+
+      if (type == 0)
+	return 0;
+
+      if (TYPE_MAIN_VARIANT (type) == float_type_node)
+	return 0;
+
+      if (C_PROMOTING_INTEGER_TYPE_P (type))
+	return 0;
+    }
+  return 1;
+}
+
+/* Return 1 if TYPE is not affected by default promotions.  */
+
+static int
+self_promoting_type_p (type)
+     tree type;
+{
+  if (TYPE_MAIN_VARIANT (type) == float_type_node)
+    return 0;
+
+  if (C_PROMOTING_INTEGER_TYPE_P (type))
+    return 0;
+
+  return 1;
+}
+
+/* Return an unsigned type the same as TYPE in other respects.  */
+
+tree
+unsigned_type (type)
+     tree type;
+{
+  tree type1 = TYPE_MAIN_VARIANT (type);
+  if (type1 == signed_char_type_node || type1 == char_type_node)
+    return unsigned_char_type_node;
+  if (type1 == integer_type_node)
+    return unsigned_type_node;
+  if (type1 == short_integer_type_node)
+    return short_unsigned_type_node;
+  if (type1 == long_integer_type_node)
+    return long_unsigned_type_node;
+  if (type1 == long_long_integer_type_node)
+    return long_long_unsigned_type_node;
+  return type;
+}
+
+/* Return a signed type the same as TYPE in other respects.  */
+
+tree
+signed_type (type)
+     tree type;
+{
+  tree type1 = TYPE_MAIN_VARIANT (type);
+  if (type1 == unsigned_char_type_node || type1 == char_type_node)
+    return signed_char_type_node;
+  if (type1 == unsigned_type_node)
+    return integer_type_node;
+  if (type1 == short_unsigned_type_node)
+    return short_integer_type_node;
+  if (type1 == long_unsigned_type_node)
+    return long_integer_type_node;
+  if (type1 == long_long_unsigned_type_node)
+    return long_long_integer_type_node;
+  return type;
+}
+
+/* Return a type the same as TYPE except unsigned or
+   signed according to UNSIGNEDP.  */
+
+tree
+signed_or_unsigned_type (unsignedp, type)
+     int unsignedp;
+     tree type;
+{
+  if (TREE_CODE (type) != INTEGER_TYPE)
+    return type;
+  if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
+    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
+  if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 
+    return unsignedp ? unsigned_type_node : integer_type_node;
+  if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node)) 
+    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
+  if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node)) 
+    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
+  if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node)) 
+    return (unsignedp ? long_long_unsigned_type_node
+	    : long_long_integer_type_node);
+  return type;
+}
+
+/* Compute the value of the `sizeof' operator.  */
+
+tree
+c_sizeof (type)
+     tree type;
+{
+  enum tree_code code = TREE_CODE (type);
+  tree t;
+
+  if (code == FUNCTION_TYPE)
+    {
+      if (pedantic || warn_pointer_arith)
+	pedwarn ("sizeof applied to a function type");
+      return size_int (1);
+    }
+  if (code == VOID_TYPE)
+    {
+      if (pedantic || warn_pointer_arith)
+	pedwarn ("sizeof applied to a void type");
+      return size_int (1);
+    }
+  if (code == ERROR_MARK)
+    return size_int (1);
+  if (TYPE_SIZE (type) == 0)
+    {
+      error ("sizeof applied to an incomplete type");
+      return size_int (0);
+    }
+
+  /* Convert in case a char is more than one unit.  */
+  t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), 
+		  size_int (TYPE_PRECISION (char_type_node)));
+  /* size_binop does not put the constant in range, so do it now.  */
+  if (TREE_CODE (t) == INTEGER_CST)
+    TREE_CONSTANT_OVERFLOW (t) |= force_fit_type (t, 0);
+  return t;
+}
+
+tree
+c_sizeof_nowarn (type)
+     tree type;
+{
+  enum tree_code code = TREE_CODE (type);
+  tree t;
+
+  if (code == FUNCTION_TYPE
+      || code == VOID_TYPE
+      || code == ERROR_MARK)
+    return size_int (1);
+  if (TYPE_SIZE (type) == 0)
+    return size_int (0);
+
+  /* Convert in case a char is more than one unit.  */
+  t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), 
+		  size_int (TYPE_PRECISION (char_type_node)));
+  force_fit_type (t, 0);
+  return t;
+}
+
+/* Compute the size to increment a pointer by.  */
+
+tree
+c_size_in_bytes (type)
+     tree type;
+{
+  enum tree_code code = TREE_CODE (type);
+  tree t;
+
+  if (code == FUNCTION_TYPE)
+    return size_int (1);
+  if (code == VOID_TYPE)
+    return size_int (1);
+  if (code == ERROR_MARK)
+    return size_int (1);
+  if (TYPE_SIZE (type) == 0)
+    {
+      error ("arithmetic on pointer to an incomplete type");
+      return size_int (1);
+    }
+
+  /* Convert in case a char is more than one unit.  */
+  t = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), 
+		     size_int (BITS_PER_UNIT));
+  force_fit_type (t, 0);
+  return t;
+}
+
+/* Implement the __alignof keyword: Return the minimum required
+   alignment of TYPE, measured in bytes.  */
+
+tree
+c_alignof (type)
+     tree type;
+{
+  enum tree_code code = TREE_CODE (type);
+
+  if (code == FUNCTION_TYPE)
+    return size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
+
+  if (code == VOID_TYPE || code == ERROR_MARK)
+    return size_int (1);
+
+  return size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
+}
+
+/* Implement the __alignof keyword: Return the minimum required
+   alignment of EXPR, measured in bytes.  For VAR_DECL's and
+   FIELD_DECL's return DECL_ALIGN (which can be set from an
+   "aligned" __attribute__ specification).  */
+
+tree
+c_alignof_expr (expr)
+     tree expr;
+{
+  if (TREE_CODE (expr) == VAR_DECL)
+    return size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
+ 
+  if (TREE_CODE (expr) == COMPONENT_REF
+      && DECL_BIT_FIELD (TREE_OPERAND (expr, 1)))
+    {
+      error ("`__alignof' applied to a bit-field");
+      return size_int (1);
+    }
+  else if (TREE_CODE (expr) == COMPONENT_REF
+      && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
+    return size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
+ 
+  if (TREE_CODE (expr) == INDIRECT_REF)
+    {
+      tree t = TREE_OPERAND (expr, 0);
+      tree best = t;
+      int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
+ 
+      while (TREE_CODE (t) == NOP_EXPR
+	      && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
+	{
+	  int thisalign;
+
+	  t = TREE_OPERAND (t, 0);
+	  thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
+	  if (thisalign > bestalign)
+	    best = t, bestalign = thisalign;
+	}
+      return c_alignof (TREE_TYPE (TREE_TYPE (best)));
+    }
+  else
+    return c_alignof (TREE_TYPE (expr));
+}
+/* Return either DECL or its known constant value (if it has one).  */
+
+static tree
+decl_constant_value (decl)
+     tree decl;
+{
+  if (! TREE_PUBLIC (decl)
+      /* Don't change a variable array bound or initial value to a constant
+	 in a place where a variable is invalid.  */
+      && current_function_decl != 0
+      && ! pedantic
+      && ! TREE_THIS_VOLATILE (decl)
+      && DECL_INITIAL (decl) != 0
+      && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
+      /* This is invalid if initial value is not constant.
+	 If it has either a function call, a memory reference,
+	 or a variable, then re-evaluating it could give different results.  */
+      && TREE_CONSTANT (DECL_INITIAL (decl))
+      /* Check for cases where this is sub-optimal, even though valid.  */
+      && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR
+      && DECL_MODE (decl) != BLKmode)
+    return DECL_INITIAL (decl);
+  return decl;
+}
+
+/* Perform default promotions for C data used in expressions.
+   Arrays and functions are converted to pointers;
+   enumeral types or short or char, to int.
+   In addition, manifest constants symbols are replaced by their values.  */
+
+tree
+default_conversion (exp)
+     tree exp;
+{
+  register tree type = TREE_TYPE (exp);
+  register enum tree_code code = TREE_CODE (type);
+
+  /* Constants can be used directly unless they're not loadable.  */
+  if (TREE_CODE (exp) == CONST_DECL)
+    exp = DECL_INITIAL (exp);
+  /* Replace a nonvolatile const static variable with its value.  */
+  else if (optimize
+	   && TREE_CODE (exp) == VAR_DECL
+	   && TREE_READONLY (exp)
+	   /* But not for iterators!  */
+	   && !ITERATOR_P (exp)
+	   && DECL_MODE (exp) != BLKmode)
+    {
+      exp = decl_constant_value (exp);
+      type = TREE_TYPE (exp);
+    }
+
+  /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
+     an lvalue.  */
+  /* Do not use STRIP_NOPS here!  It will remove conversions from pointer
+     to integer and cause infinite recursion.  */
+  while (TREE_CODE (exp) == NON_LVALUE_EXPR
+	 || (TREE_CODE (exp) == NOP_EXPR
+	     && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
+    exp = TREE_OPERAND (exp, 0);
+
+  /* Normally convert enums to int,
+     but convert wide enums to something wider.  */
+  if (code == ENUMERAL_TYPE)
+    {
+      type = type_for_size (MAX (TYPE_PRECISION (type),
+				 TYPE_PRECISION (integer_type_node)),
+			    (flag_traditional && TREE_UNSIGNED (type)));
+      return convert (type, exp);
+    }
+
+  if (C_PROMOTING_INTEGER_TYPE_P (type))
+    {
+      /* Traditionally, unsignedness is preserved in default promotions.
+         Also preserve unsignedness if not really getting any wider.  */
+      if (TREE_UNSIGNED (type)
+	  && (flag_traditional
+	      || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
+	return convert (unsigned_type_node, exp);
+      return convert (integer_type_node, exp);
+    }
+  if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
+    return convert (double_type_node, exp);
+  if (code == VOID_TYPE)
+    {
+      error ("void value not ignored as it ought to be");
+      return error_mark_node;
+    }
+  if (code == FUNCTION_TYPE)
+    {
+      return build_unary_op (ADDR_EXPR, exp, 0);
+    }
+  if (code == ARRAY_TYPE)
+    {
+      register tree adr;
+      tree restype = TREE_TYPE (type);
+      tree ptrtype;
+
+      if (TREE_CODE (exp) == INDIRECT_REF)
+	return convert (TYPE_POINTER_TO (restype),
+			TREE_OPERAND (exp, 0));
+
+      if (TREE_CODE (exp) == COMPOUND_EXPR)
+	{
+	  tree op1 = default_conversion (TREE_OPERAND (exp, 1));
+	  return build (COMPOUND_EXPR, TREE_TYPE (op1),
+			TREE_OPERAND (exp, 0), op1);
+	}
+
+      if (!lvalue_p (exp)
+	  && ! (TREE_CODE (exp) == CONSTRUCTOR && TREE_STATIC (exp)))
+	{
+	  error ("invalid use of non-lvalue array");
+	  return error_mark_node;
+	}
+
+      if (TYPE_READONLY (type) || TYPE_VOLATILE (type))
+	restype = c_build_type_variant (restype, TYPE_READONLY (type),
+					TYPE_VOLATILE (type));
+
+      ptrtype = build_pointer_type (restype);
+
+      if (TREE_CODE (exp) == VAR_DECL)
+	{
+	  /* ??? This is not really quite correct
+	     in that the type of the operand of ADDR_EXPR
+	     is not the target type of the type of the ADDR_EXPR itself.
+	     Question is, can this lossage be avoided?  */
+	  adr = build1 (ADDR_EXPR, ptrtype, exp);
+	  if (mark_addressable (exp) == 0)
+	    return error_mark_node;
+	  TREE_CONSTANT (adr) = staticp (exp);
+	  TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
+	  return adr;
+	}
+      /* This way is better for a COMPONENT_REF since it can
+	 simplify the offset for a component.  */
+      adr = build_unary_op (ADDR_EXPR, exp, 1);
+      return convert (ptrtype, adr);
+    }
+  return exp;
+}
+
+/* Make an expression to refer to the COMPONENT field of
+   structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
+
+tree
+build_component_ref (datum, component)
+     tree datum, component;
+{
+  register tree type = TREE_TYPE (datum);
+  register enum tree_code code = TREE_CODE (type);
+  register tree field = NULL;
+  register tree ref;
+
+  /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it
+     unless we are not to support things not strictly ANSI.  */
+  switch (TREE_CODE (datum))
+    {
+    case COMPOUND_EXPR:
+      {
+	tree value = build_component_ref (TREE_OPERAND (datum, 1), component);
+	return build (COMPOUND_EXPR, TREE_TYPE (value),
+		      TREE_OPERAND (datum, 0), value);
+      }
+    case COND_EXPR:
+      return build_conditional_expr
+	(TREE_OPERAND (datum, 0),
+	 build_component_ref (TREE_OPERAND (datum, 1), component),
+	 build_component_ref (TREE_OPERAND (datum, 2), component));
+    }
+
+  /* See if there is a field or component with name COMPONENT.  */
+
+  if (code == RECORD_TYPE || code == UNION_TYPE)
+    {
+      if (TYPE_SIZE (type) == 0)
+	{
+	  incomplete_type_error (NULL_TREE, type);
+	  return error_mark_node;
+	}
+
+      /* Look up component name in the structure type definition.
+
+	 If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
+	 to the field elements.  Use a binary search on this array to quickly
+	 find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
+	 will always be set for structures which have many elements.  */
+
+      if (TYPE_LANG_SPECIFIC (type))
+	{
+	  int bot, top, half;
+	  tree *field_array = &TYPE_LANG_SPECIFIC (type)->elts[0];
+
+	  field = TYPE_FIELDS (type);
+	  bot = 0;
+	  top = TYPE_LANG_SPECIFIC (type)->len;
+	  while (top - bot > 1)
+	    {
+	      int cmp;
+
+	      half = (top - bot + 1) >> 1;
+	      field = field_array[bot+half];
+	      cmp = (long)DECL_NAME (field) - (long)component;
+	      if (cmp == 0)
+		break;
+	      if (cmp < 0)
+		bot += half;
+	      else
+		top = bot + half;
+	    }
+
+	  if (DECL_NAME (field_array[bot]) == component)
+	    field = field_array[bot];
+	  else if (DECL_NAME (field) != component)
+	    field = 0;
+	}
+      else
+	{
+	  for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+	    {
+	      if (DECL_NAME (field) == component)
+		break;
+	    }
+	}
+
+      if (!field)
+	{
+	  error (code == RECORD_TYPE
+		 ? "structure has no member named `%s'"
+		 : "union has no member named `%s'",
+		 IDENTIFIER_POINTER (component));
+	  return error_mark_node;
+	}
+      if (TREE_TYPE (field) == error_mark_node)
+	return error_mark_node;
+
+      ref = build (COMPONENT_REF, TREE_TYPE (field), datum, field);
+
+      if (TREE_READONLY (datum) || TREE_READONLY (field))
+	TREE_READONLY (ref) = 1;
+      if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
+	TREE_THIS_VOLATILE (ref) = 1;
+
+      return ref;
+    }
+  else if (code != ERROR_MARK)
+    error ("request for member `%s' in something not a structure or union",
+	    IDENTIFIER_POINTER (component));
+
+  return error_mark_node;
+}
+
+/* Given an expression PTR for a pointer, return an expression
+   for the value pointed to.
+   ERRORSTRING is the name of the operator to appear in error messages.  */
+
+tree
+build_indirect_ref (ptr, errorstring)
+     tree ptr;
+     char *errorstring;
+{
+  register tree pointer = default_conversion (ptr);
+  register tree type = TREE_TYPE (pointer);
+
+  if (TREE_CODE (type) == POINTER_TYPE)
+    {
+      if (TREE_CODE (pointer) == ADDR_EXPR
+	  && !flag_volatile
+	  && (TREE_TYPE (TREE_OPERAND (pointer, 0))
+	      == TREE_TYPE (type)))
+	return TREE_OPERAND (pointer, 0);
+      else
+	{
+	  tree t = TREE_TYPE (type);
+	  register tree ref = build1 (INDIRECT_REF,
+				      TYPE_MAIN_VARIANT (t), pointer);
+
+	  if (TYPE_SIZE (t) == 0 && TREE_CODE (t) != ARRAY_TYPE)
+	    {
+	      error ("dereferencing pointer to incomplete type");
+	      return error_mark_node;
+	    }
+	  if (TREE_CODE (t) == VOID_TYPE)
+	    warning ("dereferencing `void *' pointer");
+
+	  /* We *must* set TREE_READONLY when dereferencing a pointer to const,
+	     so that we get the proper error message if the result is used
+	     to assign to.  Also, &* is supposed to be a no-op.
+	     And ANSI C seems to specify that the type of the result
+	     should be the const type.  */
+	  /* A de-reference of a pointer to const is not a const.  It is valid
+	     to change it via some other pointer.  */
+	  TREE_READONLY (ref) = TYPE_READONLY (t);
+	  TREE_SIDE_EFFECTS (ref)
+	    = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
+	  TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t) || flag_volatile;
+	  return ref;
+	}
+    }
+  else if (TREE_CODE (pointer) != ERROR_MARK)
+    error ("invalid type argument of `%s'", errorstring);
+  return error_mark_node;
+}
+
+/* This handles expressions of the form "a[i]", which denotes
+   an array reference.
+
+   This is logically equivalent in C to *(a+i), but we may do it differently.
+   If A is a variable or a member, we generate a primitive ARRAY_REF.
+   This avoids forcing the array out of registers, and can work on
+   arrays that are not lvalues (for example, members of structures returned
+   by functions).  */
+
+tree
+build_array_ref (array, index)
+     tree array, index;
+{
+  if (index == 0)
+    {
+      error ("subscript missing in array reference");
+      return error_mark_node;
+    }
+
+  if (TREE_TYPE (array) == error_mark_node
+      || TREE_TYPE (index) == error_mark_node)
+    return error_mark_node;
+
+  if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
+      && TREE_CODE (array) != INDIRECT_REF)
+    {
+      tree rval, type;
+
+      /* Subscripting with type char is likely to lose
+	 on a machine where chars are signed.
+	 So warn on any machine, but optionally.
+	 Don't warn for unsigned char since that type is safe.
+	 Don't warn for signed char because anyone who uses that
+	 must have done so deliberately.  */
+      if (warn_char_subscripts
+	  && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
+	warning ("array subscript has type `char'");
+
+      /* Apply default promotions *after* noticing character types.  */
+      index = default_conversion (index);
+
+      /* Require integer *after* promotion, for sake of enums.  */
+      if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
+	{
+	  error ("array subscript is not an integer");
+	  return error_mark_node;
+	}
+
+      /* An array that is indexed by a non-constant
+	 cannot be stored in a register; we must be able to do
+	 address arithmetic on its address.
+	 Likewise an array of elements of variable size.  */
+      if (TREE_CODE (index) != INTEGER_CST
+	  || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
+	      && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
+	{
+	  if (mark_addressable (array) == 0)
+	    return error_mark_node;
+	}
+
+      if (pedantic && !lvalue_p (array))
+	{
+	  if (DECL_REGISTER (array))
+	    pedwarn ("ANSI C forbids subscripting `register' array");
+	  else
+	    pedwarn ("ANSI C forbids subscripting non-lvalue array");
+	}
+
+      if (pedantic)
+	{
+	  tree foo = array;
+	  while (TREE_CODE (foo) == COMPONENT_REF)
+	    foo = TREE_OPERAND (foo, 0);
+	  if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
+	    pedwarn ("ANSI C forbids subscripting non-lvalue array");
+	}
+
+      type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
+      rval = build (ARRAY_REF, type, array, index);
+      /* Array ref is const/volatile if the array elements are
+         or if the array is.  */
+      TREE_READONLY (rval)
+	|= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
+	    | TREE_READONLY (array));
+      TREE_SIDE_EFFECTS (rval)
+	|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
+	    | TREE_SIDE_EFFECTS (array));
+      TREE_THIS_VOLATILE (rval)
+	|= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
+	    /* This was added by rms on 16 Nov 91.
+	       It fixes  vol struct foo *a;  a->elts[1] 
+	       in an inline function.
+	       Hope it doesn't break something else.  */
+	    | TREE_THIS_VOLATILE (array));
+      return require_complete_type (fold (rval));
+    }
+
+  {
+    tree ar = default_conversion (array);
+    tree ind = default_conversion (index);
+
+    /* Put the integer in IND to simplify error checking.  */
+    if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
+      {
+	tree temp = ar;
+	ar = ind;
+	ind = temp;
+      }
+
+    if (ar == error_mark_node)
+      return ar;
+
+    if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE)
+      {
+	error ("subscripted value is neither array nor pointer");
+	return error_mark_node;
+      }
+    if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
+      {
+	error ("array subscript is not an integer");
+	return error_mark_node;
+      }
+
+    return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
+			       "array indexing");
+  }
+}
+
+/* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against PARAMS.  */
+
+#define ISDIGIT(c)	((c) >= '0' && (c) <= '9')
+
+#define T_I	&integer_type_node
+#define T_L	&long_integer_type_node
+#define T_S	&short_integer_type_node
+#define T_UI	&unsigned_type_node
+#define T_UL	&long_unsigned_type_node
+#define T_US	&short_unsigned_type_node
+#define T_F	&float_type_node
+#define T_D	&double_type_node
+#define T_LD	&long_double_type_node
+#define T_C	&char_type_node
+#define T_V	&void_type_node
+#define T_W	&wchar_type_node
+
+typedef struct
+{
+  char *format_chars;
+  int pointer_count;
+  /* Type of argument if no length modifier is used.  */
+  tree *nolen;
+  /* Type of argument if length modifier for shortening is used.
+     If NULL, then this modifier is not allowed.  */
+  tree *hlen;
+  /* Type of argument if length modifier `l' is used.
+     If NULL, then this modifier is not allowed.  */
+  tree *llen;
+  /* Type of argument if length modifier `L' is used.
+     If NULL, then this modifier is not allowed.  */
+  tree *bigllen;
+  /* List of other modifier characters allowed with these options.  */
+  char *flag_chars;
+} format_char_info;
+
+static format_char_info print_table[]
+  = {
+      { "di",		0,	T_I,	T_I,	T_L,	NULL,	"-wp0 +" },
+      { "oxX",		0,	T_UI,	T_UI,	T_UL,	NULL,	"-wp0#" },
+      { "u",		0,	T_UI,	T_UI,	T_UL,	NULL,	"-wp0" },
+      { "feEgG",	0,	T_D,	NULL,	NULL,	T_LD,	"-wp0 +#" },
+      { "c",		0,	T_I,	NULL,	T_W,	NULL,	"-w" },
+      { "C",		0,	T_W,	NULL,	NULL,	NULL,	"-w" },
+      { "s",		1,	T_C,	NULL,	T_W,	NULL,	"-wp" },
+      { "S",		1,	T_W,	NULL,	NULL,	NULL,	"-wp" },
+      { "p",		1,	T_V,	NULL,	NULL,	NULL,	"-" },
+      { "n",		1,	T_I,	T_S,	T_L,	NULL,	"" },
+      { NULL }
+    };
+
+static format_char_info scan_table[]
+  = {
+      { "di",		1,	T_I,	T_S,	T_L,	NULL,	"*" },
+      { "ouxX",		1,	T_UI,	T_US,	T_UL,	NULL,	"*" },	
+      { "efgEG",	1,	T_F,	NULL,	T_D,	T_LD,	"*" },
+      { "sc",		1,	T_C,	NULL,	T_W,	NULL,	"*" },
+      { "[",		1,	T_C,	NULL,	NULL,	NULL,	"*" },
+      { "C",		1,	T_W,	NULL,	NULL,	NULL,	"*" },
+      { "S",		1,	T_W,	NULL,	NULL,	NULL,	"*" },
+      { "p",		2,	T_V,	NULL,	NULL,	NULL,	"*" },
+      { "n",		1,	T_I,	T_S,	T_L,	NULL,	"" },
+      { NULL }
+    };
+
+typedef struct
+{
+  tree function_ident;		/* identifier such as "printf" */
+  int is_scan;			/* TRUE if *scanf */
+  int format_num;		/* number of format argument */
+  int first_arg_num;		/* number of first arg (zero for varargs) */
+} function_info;
+
+static unsigned int function_info_entries = 0;
+static function_info *function_info_table = NULL;
+
+/* Record information for argument format checking.  FUNCTION_IDENT is
+   the identifier node for the name of the function to check (its decl
+   need not exist yet).  IS_SCAN is true for scanf-type format checking;
+   false indicates printf-style format checking.  FORMAT_NUM is the number
+   of the argument which is the format control string (starting from 1).
+   FIRST_ARG_NUM is the number of the first actual argument to check
+   against teh format string, or zero if no checking is not be done
+   (e.g. for varargs such as vfprintf).  */
+
+void
+record_format_info (function_ident, is_scan, format_num, first_arg_num)
+      tree function_ident;
+      int is_scan;
+      int format_num;
+      int first_arg_num;
+{
+  function_info *info;
+  
+  function_info_entries++;
+  if (function_info_table)
+    function_info_table
+      = (function_info *) xrealloc (function_info_table,
+				    function_info_entries * sizeof (function_info));
+  else
+    function_info_table = (function_info *) xmalloc (sizeof (function_info));
+
+  info = &function_info_table[function_info_entries - 1];
+  
+  info->function_ident = function_ident;
+  info->is_scan = is_scan;
+  info->format_num = format_num;
+  info->first_arg_num = first_arg_num;
+}
+
+/* Initialize the table of functions to perform format checking on.
+   The ANSI functions are always checked (whether <stdio.h> is
+   included or not), since it is common to call printf without
+   including <stdio.h>.  There shouldn't be a problem with this,
+   since ANSI reserves these function names whether you include the
+   header file or not.  In any case, the checking is harmless.  */
+
+void
+init_format_info_table ()
+{
+  record_format_info (get_identifier ("printf"), 0, 1, 2);
+  record_format_info (get_identifier ("fprintf"), 0, 2, 3);
+  record_format_info (get_identifier ("sprintf"), 0, 2, 3);
+  record_format_info (get_identifier ("scanf"), 1, 1, 2);
+  record_format_info (get_identifier ("fscanf"), 1, 2, 3);
+  record_format_info (get_identifier ("sscanf"), 1, 2, 3);
+  record_format_info (get_identifier ("vprintf"), 0, 1, 0);
+  record_format_info (get_identifier ("vfprintf"), 0, 2, 0);
+  record_format_info (get_identifier ("vsprintf"), 0, 2, 0);
+}
+
+static char	tfaff[] = "too few arguments for format";
+
+/* Check the argument list of a call to printf, scanf, etc.
+   INFO points to the element of function_info_table.
+   PARAMS is the list of argument values.  */
+
+static void
+check_format (info, params)
+     function_info *info;
+     tree params;
+{
+  int i;
+  int arg_num;
+  int suppressed, wide, precise;
+  int length_char;
+  int format_char;
+  int format_length;
+  tree format_tree;
+  tree cur_param;
+  tree cur_type;
+  tree wanted_type;
+  char *format_chars;
+  format_char_info *fci;
+  static char message[132];
+  char flag_chars[8];
+
+  /* Skip to format argument.  If the argument isn't available, there's
+     no work for us to do; prototype checking will catch the problem.  */
+  for (arg_num = 1; ; ++arg_num)
+    {
+      if (params == 0)
+	return;
+      if (arg_num == info->format_num)
+	break;
+      params = TREE_CHAIN (params);
+    }
+  format_tree = TREE_VALUE (params);
+  params = TREE_CHAIN (params);
+  if (format_tree == 0)
+    return;
+  /* We can only check the format if it's a string constant.  */
+  while (TREE_CODE (format_tree) == NOP_EXPR)
+    format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */
+  if (format_tree == null_pointer_node)
+    {
+      warning ("null format string");
+      return;
+    }
+  if (TREE_CODE (format_tree) != ADDR_EXPR)
+    return;
+  format_tree = TREE_OPERAND (format_tree, 0);
+  if (TREE_CODE (format_tree) != STRING_CST)
+    return;
+  format_chars = TREE_STRING_POINTER (format_tree);
+  format_length = TREE_STRING_LENGTH (format_tree);
+  if (format_length <= 1)
+    warning ("zero-length format string");
+  if (format_chars[--format_length] != 0)
+    {
+      warning ("unterminated format string");
+      return;
+    }
+  /* Skip to first argument to check.  */
+  while (arg_num + 1 < info->first_arg_num)
+    {
+      if (params == 0)
+	return;
+      params = TREE_CHAIN (params);
+      ++arg_num;
+    }
+  while (1)
+    {
+      if (*format_chars == 0)
+	{
+	  if (format_chars - TREE_STRING_POINTER (format_tree) != format_length)
+	    warning ("embedded `\\0' in format");
+	  if (info->first_arg_num != 0 && params != 0)
+	    warning ("too many arguments for format");
+	  return;
+	}
+      if (*format_chars++ != '%')
+	continue;
+      if (*format_chars == 0)
+	{
+	  warning ("spurious trailing `%%' in format");
+	  continue;
+	}
+      if (*format_chars == '%')
+	{
+	  ++format_chars;
+	  continue;
+	}
+      flag_chars[0] = 0;
+      suppressed = wide = precise = FALSE;
+      if (info->is_scan)
+	{
+	  suppressed = *format_chars == '*';
+	  if (suppressed)
+	    ++format_chars;
+	  while (ISDIGIT (*format_chars))
+	    ++format_chars;
+	}
+      else
+	{
+	  while (*format_chars != 0 && index (" +#0-", *format_chars) != 0)
+	    {
+	      if (index (flag_chars, *format_chars) != 0)
+		{
+		  sprintf (message, "repeated `%c' flag in format",
+			   *format_chars);
+		  warning (message);
+		}
+	      i = strlen (flag_chars);
+	      flag_chars[i++] = *format_chars++;
+	      flag_chars[i] = 0;
+	    }
+	  /* "If the space and + flags both appear, 
+	     the space flag will be ignored."  */
+	  if (index (flag_chars, ' ') != 0
+	      && index (flag_chars, '+') != 0)
+	    warning ("use of both ` ' and `+' flags in format");
+	  /* "If the 0 and - flags both appear,
+	     the 0 flag will be ignored."  */
+	  if (index (flag_chars, '0') != 0
+	      && index (flag_chars, '-') != 0)
+	    warning ("use of both `0' and `-' flags in format");
+	  if (*format_chars == '*')
+	    {
+	      wide = TRUE;
+	      /* "...a field width...may be indicated by an asterisk.
+		 In this case, an int argument supplies the field width..."  */
+	      ++format_chars;
+	      if (params == 0)
+		{
+		  warning (tfaff);
+		  return;
+		}
+	      if (info->first_arg_num != 0)
+		{
+		  cur_param = TREE_VALUE (params);
+		  params = TREE_CHAIN (params);
+		  ++arg_num;
+		  /* size_t is generally not valid here.
+		     It will work on most machines, because size_t and int
+		     have the same mode.  But might as well warn anyway,
+		     since it will fail on other machines.  */
+		  if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
+		      != integer_type_node)
+		    {
+		      sprintf (message,
+			       "field width is not type int (arg %d)",
+			       arg_num);
+		      warning (message);
+		    }
+		}
+	    }
+	  else
+	    {
+	      while (ISDIGIT (*format_chars))
+		{
+		  wide = TRUE;
+		  ++format_chars;
+		}
+	    }
+	  if (*format_chars == '.')
+	    {
+	      precise = TRUE;
+	      ++format_chars;
+	      if (*format_chars != '*' && !ISDIGIT (*format_chars))
+		warning ("`.' not followed by `*' or digit in format");
+	      /* "...a...precision...may be indicated by an asterisk.
+		 In this case, an int argument supplies the...precision."  */
+	      if (*format_chars == '*')
+		{
+		  if (info->first_arg_num != 0)
+		    {
+		      ++format_chars;
+		      if (params == 0)
+		        {
+			  warning (tfaff);
+			  return;
+			}
+		      cur_param = TREE_VALUE (params);
+		      params = TREE_CHAIN (params);
+		      ++arg_num;
+		      if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
+			  != integer_type_node)
+		        {
+		          sprintf (message,
+				   "field width is not type int (arg %d)",
+				   arg_num);
+		          warning (message);
+		        }
+		    }
+		}
+	      else
+		{
+		  while (ISDIGIT (*format_chars))
+		    ++format_chars;
+		}
+	    }
+	}
+      if (*format_chars == 'h' || *format_chars == 'l' || *format_chars == 'L')
+	length_char = *format_chars++;
+      else
+	length_char = 0;
+      if (suppressed && length_char != 0)
+	{
+	  sprintf (message,
+		   "use of `*' and `%c' together in format",
+		   length_char);
+	  warning (message);
+	}
+      format_char = *format_chars;
+      if (format_char == 0)
+	{
+	  warning ("conversion lacks type at end of format");
+	  continue;
+	}
+      format_chars++;
+      fci = info->is_scan ? scan_table : print_table;
+      while (1)
+	{
+	  if (fci->format_chars == 0
+	      || index (fci->format_chars, format_char) != 0)
+	    break;
+	  ++fci;
+	}
+      if (fci->format_chars == 0)
+	{
+	  if (format_char >= 040 && format_char < 0177)
+	    sprintf (message,
+		     "unknown conversion type character `%c' in format",
+		     format_char);
+	  else
+	    sprintf (message,
+		     "unknown conversion type character 0x%x in format",
+		     format_char);
+	  warning (message);
+	  continue;
+	}
+      if (wide && index (fci->flag_chars, 'w') == 0)
+	{
+	  sprintf (message, "width used with `%c' format",
+		   format_char);
+	  warning (message);
+	}
+      if (precise && index (fci->flag_chars, 'p') == 0)
+	{
+	  sprintf (message, "precision used with `%c' format",
+		   format_char);
+	  warning (message);
+	}
+      if (suppressed)
+	{
+	  if (index (fci->flag_chars, '*') == 0)
+	    {
+	      sprintf (message,
+		       "suppression of `%c' conversion in format",
+		       format_char);
+	      warning (message);
+	    }
+	  continue;
+	}
+      for (i = 0; flag_chars[i] != 0; ++i)
+	{
+	  if (index (fci->flag_chars, flag_chars[i]) == 0)
+	    {
+	      sprintf (message, "flag `%c' used with type `%c'",
+		       flag_chars[i], format_char);
+	      warning (message);
+	    }
+	}
+      if (precise && index (flag_chars, '0') != 0
+	  && (format_char == 'd' || format_char == 'i'
+	      || format_char == 'o' || format_char == 'u'
+	      || format_char == 'x' || format_char == 'x'))
+	{
+	  sprintf (message,
+		   "precision and `0' flag not both allowed with `%c' format",
+		   format_char);
+	  warning (message);
+	}
+      switch (length_char)
+	{
+	default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break;
+	case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break;
+	case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
+	case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
+	}
+      if (wanted_type == 0)
+	{
+	  sprintf (message,
+		   "use of `%c' length character with `%c' type character",
+		   length_char, format_char);
+	  warning (message);
+	}
+
+      /*
+       ** XXX -- should kvetch about stuff such as
+       **	{
+       **		const int	i;
+       **
+       **		scanf ("%d", &i);
+       **	}
+       */
+
+      /* Finally. . .check type of argument against desired type!  */
+      if (info->first_arg_num == 0)
+	continue;
+      if (params == 0)
+	{
+	  warning (tfaff);
+	  return;
+	}
+      cur_param = TREE_VALUE (params);
+      params = TREE_CHAIN (params);
+      ++arg_num;
+      cur_type = TREE_TYPE (cur_param);
+
+      /* Check the types of any additional pointer arguments
+	 that precede the "real" argument.  */
+      for (i = 0; i < fci->pointer_count; ++i)
+	{
+	  if (TREE_CODE (cur_type) == POINTER_TYPE)
+	    {
+	      cur_type = TREE_TYPE (cur_type);
+	      continue;
+	    }
+	  sprintf (message,
+		   "format argument is not a %s (arg %d)",
+		   ((fci->pointer_count == 1) ? "pointer" : "pointer to a pointer"),
+		   arg_num);
+	  warning (message);
+	  break;
+	}
+
+      /* Check the type of the "real" argument, if there's a type we want.  */
+      if (i == fci->pointer_count && wanted_type != 0
+	  && wanted_type != TYPE_MAIN_VARIANT (cur_type)
+	  /* If we want `void *', allow any pointer type.
+	     (Anything else would already have got a warning.)  */
+	  && ! (wanted_type == void_type_node
+		&& fci->pointer_count > 0)
+	  /* Don't warn about differences merely in signedness.  */
+	  && !(TREE_CODE (wanted_type) == INTEGER_TYPE
+	       && TREE_CODE (cur_type) == INTEGER_TYPE
+	       && TYPE_PRECISION (wanted_type) == TYPE_PRECISION (cur_type)))
+	{
+	  register char *this;
+	  register char *that;
+  
+	  this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
+	  that = 0;
+	  if (TREE_CODE (cur_type) != ERROR_MARK
+	      && TYPE_NAME (cur_type) != 0
+	      && TREE_CODE (cur_type) != INTEGER_TYPE
+	      && !(TREE_CODE (cur_type) == POINTER_TYPE
+		   && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE))
+	    {
+	      if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL
+		  && DECL_NAME (TYPE_NAME (cur_type)) != 0)
+		that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
+	      else
+		that = IDENTIFIER_POINTER (TYPE_NAME (cur_type));
+	    }
+
+	  /* A nameless type can't possibly match what the format wants.
+	     So there will be a warning for it.
+	     Make up a string to describe vaguely what it is.  */
+	  if (that == 0)
+	    {
+	      if (TREE_CODE (cur_type) == POINTER_TYPE)
+		that = "pointer";
+	      else
+		that = "different type";
+	    }
+
+	  if (strcmp (this, that) != 0)
+	    {
+	      sprintf (message, "%s format, %s arg (arg %d)",
+			this, that, arg_num);
+	      warning (message);
+	    }
+	}
+    }
+}
+
+/* Build a function call to function FUNCTION with parameters PARAMS.
+   PARAMS is a list--a chain of TREE_LIST nodes--in which the
+   TREE_VALUE of each node is a parameter-expression.
+   FUNCTION's data type may be a function type or a pointer-to-function.  */
+
+tree
+build_function_call (function, params)
+     tree function, params;
+{
+  register tree fntype, fundecl;
+  register tree coerced_params;
+  tree name = NULL_TREE;
+
+  /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
+  STRIP_TYPE_NOPS (function);
+
+  /* Convert anything with function type to a pointer-to-function.  */
+  if (TREE_CODE (function) == FUNCTION_DECL)
+    {
+      name = DECL_NAME (function);
+      /* Differs from default_conversion by not setting TREE_ADDRESSABLE
+	 (because calling an inline function does not mean the function
+	 needs to be separately compiled).  */
+      fntype = build_type_variant (TREE_TYPE (function),
+				   TREE_READONLY (function),
+				   TREE_THIS_VOLATILE (function));
+      fundecl = function;
+      function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
+    }
+  else
+    function = default_conversion (function);
+
+  fntype = TREE_TYPE (function);
+
+  if (TREE_CODE (fntype) == ERROR_MARK)
+    return error_mark_node;
+
+  if (!(TREE_CODE (fntype) == POINTER_TYPE
+	&& TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
+    {
+      error ("called object is not a function");
+      return error_mark_node;
+    }
+
+  /* fntype now gets the type of function pointed to.  */
+  fntype = TREE_TYPE (fntype);
+
+  /* Convert the parameters to the types declared in the
+     function prototype, or apply default promotions.  */
+
+  coerced_params
+    = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
+
+  /* Check for errors in format strings.  */
+  if (warn_format && name != 0)
+    {
+      unsigned int i;
+
+      /* See if this function is a format function.  */
+      for (i = 0; i < function_info_entries; i++)
+	if (function_info_table[i].function_ident == name)
+	  {
+	    register char *message;
+
+	    /* If so, check it.  */
+	    check_format (&function_info_table[i], coerced_params);
+	    break;
+	  }
+    }
+
+  /* Recognize certain built-in functions so we can make tree-codes
+     other than CALL_EXPR.  We do this when it enables fold-const.c
+     to do something useful.  */
+
+  if (TREE_CODE (function) == ADDR_EXPR
+      && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
+      && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
+    switch (DECL_FUNCTION_CODE (TREE_OPERAND (function, 0)))
+      {
+      case BUILT_IN_ABS:
+      case BUILT_IN_LABS:
+      case BUILT_IN_FABS:
+	if (coerced_params == 0)
+	  return integer_zero_node;
+	return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
+      }
+
+  {
+    register tree result
+      = build (CALL_EXPR, TREE_TYPE (fntype),
+	       function, coerced_params, NULL_TREE);
+
+    TREE_SIDE_EFFECTS (result) = 1;
+    if (TREE_TYPE (result) == void_type_node)
+      return result;
+    return require_complete_type (result);
+  }
+}
+
+/* Convert the argument expressions in the list VALUES
+   to the types in the list TYPELIST.  The result is a list of converted
+   argument expressions.
+
+   If TYPELIST is exhausted, or when an element has NULL as its type,
+   perform the default conversions.
+
+   PARMLIST is the chain of parm decls for the function being called.
+   It may be 0, if that info is not available.
+   It is used only for generating error messages.
+
+   NAME is an IDENTIFIER_NODE or 0.  It is used only for error messages.
+
+   This is also where warnings about wrong number of args are generated.
+
+   Both VALUES and the returned value are chains of TREE_LIST nodes
+   with the elements of the list in the TREE_VALUE slots of those nodes.  */
+
+static tree
+convert_arguments (typelist, values, name, fundecl)
+     tree typelist, values, name, fundecl;
+{
+  register tree typetail, valtail;
+  register tree result = NULL;
+  int parmnum;
+
+  /* Scan the given expressions and types, producing individual
+     converted arguments and pushing them on RESULT in reverse order.  */
+
+  for (valtail = values, typetail = typelist, parmnum = 0;
+       valtail;
+       valtail = TREE_CHAIN (valtail), parmnum++)
+    {
+      register tree type = typetail ? TREE_VALUE (typetail) : 0;
+      register tree val = TREE_VALUE (valtail);
+
+      if (type == void_type_node)
+	{
+	  if (name)
+	    error ("too many arguments to function `%s'",
+		   IDENTIFIER_POINTER (name));
+	  else
+	    error ("too many arguments to function");
+	  break;
+	}
+
+      /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+      /* Do not use STRIP_NOPS here!  We do not want an enumerator with value 0
+	 to convert automatically to a pointer.  */
+      if (TREE_CODE (val) == NON_LVALUE_EXPR)
+	val = TREE_OPERAND (val, 0);
+
+      if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE
+	  || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE)
+	val = default_conversion (val);
+
+      val = require_complete_type (val);
+
+      if (type != 0)
+	{
+	  /* Formal parm type is specified by a function prototype.  */
+	  tree parmval;
+
+	  if (TYPE_SIZE (type) == 0)
+	    {
+	      error ("type of formal parameter %d is incomplete", parmnum + 1);
+	      parmval = val;
+	    }
+	  else
+	    {
+	      tree parmname;
+#ifdef PROMOTE_PROTOTYPES
+	      /* Rather than truncating and then reextending,
+		 convert directly to int, if that's the type we will want.  */
+	      if (! flag_traditional
+		  && TREE_CODE (type) == INTEGER_TYPE
+		  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
+		type = integer_type_node;
+#endif
+
+#if 0 /* This turns out not to win--there's no way to write a prototype
+	 for a function whose arg type is a union with no tag.  */
+	      /* Nameless union automatically casts the types it contains.  */
+	      if (TREE_CODE (type) == UNION_TYPE && TYPE_NAME (type) == 0)
+		{
+		  tree field;
+
+		  for (field = TYPE_FIELDS (type); field;
+		       field = TREE_CHAIN (field))
+		    if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
+				   TYPE_MAIN_VARIANT (TREE_TYPE (val))))
+		      break;
+
+		  if (field)
+		    val = build1 (CONVERT_EXPR, type, val);
+		}
+#endif
+
+	      /* Optionally warn about conversions that
+		 differ from the default conversions.  */
+	      if (warn_conversion)
+		{
+		  int formal_prec = TYPE_PRECISION (type);
+
+		  if (TREE_CODE (type) != REAL_TYPE
+		      && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
+		    warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
+		  else if (TREE_CODE (type) == REAL_TYPE
+		      && TREE_CODE (TREE_TYPE (val)) != REAL_TYPE)
+		    warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
+		  else if (TREE_CODE (type) == REAL_TYPE
+			   && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
+		    {
+		      /* Warn if any argument is passed as `float',
+			 since without a prototype it would be `double'.  */
+		      if (formal_prec == TYPE_PRECISION (float_type_node))
+			warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
+		    }
+		  /* Detect integer changing in width or signedness.  */
+		  else if ((TREE_CODE (type) == INTEGER_TYPE
+			    || TREE_CODE (type) == ENUMERAL_TYPE)
+			   && (TREE_CODE (TREE_TYPE (val)) == INTEGER_TYPE
+			       || TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE))
+		    {
+		      tree would_have_been = default_conversion (val);
+		      tree type1 = TREE_TYPE (would_have_been);
+
+		      if (TREE_CODE (type) == ENUMERAL_TYPE
+			  && type == TREE_TYPE (val))
+			/* No warning if function asks for enum
+			   and the actual arg is that enum type.  */
+			;
+		      else if (formal_prec != TYPE_PRECISION (type1))
+			warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
+		      else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
+			;
+		      /* Don't complain if the formal parameter type
+			 is an enum, because we can't tell now whether
+			 the value was an enum--even the same enum.  */
+		      else if (TREE_CODE (type) == ENUMERAL_TYPE)
+			;
+		      else if (TREE_CODE (val) == INTEGER_CST
+			       && int_fits_type_p (val, type))
+			/* Change in signedness doesn't matter
+			   if a constant value is unaffected.  */
+			;
+		      else if (TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE
+			       && int_fits_type_p (TYPE_MIN_VALUE (TREE_TYPE (val)), type)
+			       && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (val)), type))
+			/* Change in signedness doesn't matter
+			   if an enum value is unaffected.  */
+			;
+		      else if (TREE_UNSIGNED (type))
+			warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
+		      else
+			warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
+		    }
+		}
+
+	      parmval = convert_for_assignment (type, val, 
+					        (char *)0, /* arg passing  */
+						fundecl, name, parmnum + 1);
+	      
+#ifdef PROMOTE_PROTOTYPES
+	      if (TREE_CODE (type) == INTEGER_TYPE
+		  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
+		parmval = default_conversion (parmval);
+#endif
+	    }
+	  result = tree_cons (NULL_TREE, parmval, result);
+	}
+      else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
+               && (TYPE_PRECISION (TREE_TYPE (val))
+	           < TYPE_PRECISION (double_type_node)))
+	/* Convert `float' to `double'.  */
+	result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
+      else
+	/* Convert `short' and `char' to full-size `int'.  */
+	result = tree_cons (NULL_TREE, default_conversion (val), result);
+
+      if (typetail)
+	typetail = TREE_CHAIN (typetail);
+    }
+
+  if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
+    {
+      if (name)
+	error ("too few arguments to function `%s'",
+	       IDENTIFIER_POINTER (name));
+      else
+	error ("too few arguments to function");
+    }
+
+  return nreverse (result);
+}
+
+/* This is the entry point used by the parser
+   for binary operators in the input.
+   In addition to constructing the expression,
+   we check for operands that were written with other binary operators
+   in a way that is likely to confuse the user.  */
+
+tree
+parser_build_binary_op (code, arg1, arg2)
+     enum tree_code code;
+     tree arg1, arg2;
+{
+  tree result = build_binary_op (code, arg1, arg2, 1);
+
+  char class;
+  char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
+  char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
+  enum tree_code code1 = ERROR_MARK;
+  enum tree_code code2 = ERROR_MARK;
+
+  if (class1 == 'e' || class1 == '1'
+      || class1 == '2' || class1 == '<')
+    code1 = C_EXP_ORIGINAL_CODE (arg1);
+  if (class2 == 'e' || class2 == '1'
+      || class2 == '2' || class2 == '<')
+    code2 = C_EXP_ORIGINAL_CODE (arg2);
+
+  /* Check for cases such as x+y<<z which users are likely
+     to misinterpret.  If parens are used, C_EXP_ORIGINAL_CODE
+     is cleared to prevent these warnings.  */
+  if (warn_parentheses)
+    {
+      if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
+	{
+	  if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
+	      || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
+	    warning ("suggest parentheses around + or - inside shift");
+	}
+
+      if (code == TRUTH_ORIF_EXPR)
+	{
+	  if (code1 == TRUTH_ANDIF_EXPR
+	      || code2 == TRUTH_ANDIF_EXPR)
+	    warning ("suggest parentheses around && within ||");
+	}
+
+      if (code == BIT_IOR_EXPR)
+	{
+	  if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
+	      || code1 == PLUS_EXPR || code1 == MINUS_EXPR
+	      || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
+	      || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
+	    warning ("suggest parentheses around arithmetic in operand of |");
+	}
+
+      if (code == BIT_XOR_EXPR)
+	{
+	  if (code1 == BIT_AND_EXPR
+	      || code1 == PLUS_EXPR || code1 == MINUS_EXPR
+	      || code2 == BIT_AND_EXPR
+	      || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
+	    warning ("suggest parentheses around arithmetic in operand of ^");
+	}
+
+      if (code == BIT_AND_EXPR)
+	{
+	  if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
+	      || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
+	    warning ("suggest parentheses around + or - in operand of &");
+	}
+    }
+
+  /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
+  if (TREE_CODE_CLASS (code) == '<' && extra_warnings
+      && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
+    warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
+
+  unsigned_conversion_warning (result, arg1);
+  unsigned_conversion_warning (result, arg2);
+  overflow_warning (result);
+
+  class = TREE_CODE_CLASS (TREE_CODE (result));
+
+  /* Record the code that was specified in the source,
+     for the sake of warnings about confusing nesting.  */
+  if (class == 'e' || class == '1'
+      || class == '2' || class == '<')
+    C_SET_EXP_ORIGINAL_CODE (result, code);
+  else
+    {
+      int flag = TREE_CONSTANT (result);
+      /* We use NOP_EXPR rather than NON_LVALUE_EXPR
+	 so that convert_for_assignment won't strip it.
+	 That way, we get warnings for things like p = (1 - 1).  */
+      result = build1 (NOP_EXPR, TREE_TYPE (result), result);
+      C_SET_EXP_ORIGINAL_CODE (result, code);
+      TREE_CONSTANT (result) = flag;
+    }
+
+  return result;
+}
+
+/* Build a binary-operation expression without default conversions.
+   CODE is the kind of expression to build.
+   This function differs from `build' in several ways:
+   the data type of the result is computed and recorded in it,
+   warnings are generated if arg data types are invalid,
+   special handling for addition and subtraction of pointers is known,
+   and some optimization is done (operations on narrow ints
+   are done in the narrower type when that gives the same result).
+   Constant folding is also done before the result is returned.
+
+   Note that the operands will never have enumeral types, or function
+   or array types, because either they will have the default conversions
+   performed or they have both just been converted to some other type in which
+   the arithmetic is to be done.  */
+
+tree
+build_binary_op (code, orig_op0, orig_op1, convert_p)
+     enum tree_code code;
+     tree orig_op0, orig_op1;
+     int convert_p;
+{
+  tree type0, type1;
+  register enum tree_code code0, code1;
+  tree op0, op1;
+
+  /* Expression code to give to the expression when it is built.
+     Normally this is CODE, which is what the caller asked for,
+     but in some special cases we change it.  */
+  register enum tree_code resultcode = code;
+
+  /* Data type in which the computation is to be performed.
+     In the simplest cases this is the common type of the arguments.  */
+  register tree result_type = NULL;
+
+  /* Nonzero means operands have already been type-converted
+     in whatever way is necessary.
+     Zero means they need to be converted to RESULT_TYPE.  */
+  int converted = 0;
+
+  /* Nonzero means after finally constructing the expression
+     give it this type.  Otherwise, give it type RESULT_TYPE.  */
+  tree final_type = 0;
+
+  /* Nonzero if this is an operation like MIN or MAX which can
+     safely be computed in short if both args are promoted shorts.
+     Also implies COMMON.
+     -1 indicates a bitwise operation; this makes a difference
+     in the exact conditions for when it is safe to do the operation
+     in a narrower mode.  */
+  int shorten = 0;
+
+  /* Nonzero if this is a comparison operation;
+     if both args are promoted shorts, compare the original shorts.
+     Also implies COMMON.  */
+  int short_compare = 0;
+
+  /* Nonzero if this is a right-shift operation, which can be computed on the
+     original short and then promoted if the operand is a promoted short.  */
+  int short_shift = 0;
+
+  /* Nonzero means set RESULT_TYPE to the common type of the args.  */
+  int common = 0;
+
+  if (convert_p)
+    {
+      op0 = default_conversion (orig_op0);
+      op1 = default_conversion (orig_op1);
+    }
+  else
+    {
+      op0 = orig_op0;
+      op1 = orig_op1;
+    }
+
+  type0 = TREE_TYPE (op0);
+  type1 = TREE_TYPE (op1);
+
+  /* The expression codes of the data types of the arguments tell us
+     whether the arguments are integers, floating, pointers, etc.  */
+  code0 = TREE_CODE (type0);
+  code1 = TREE_CODE (type1);
+
+  /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
+  STRIP_TYPE_NOPS (op0);
+  STRIP_TYPE_NOPS (op1);
+
+  /* If an error was already reported for one of the arguments,
+     avoid reporting another error.  */
+
+  if (code0 == ERROR_MARK || code1 == ERROR_MARK)
+    return error_mark_node;
+
+  switch (code)
+    {
+    case PLUS_EXPR:
+      /* Handle the pointer + int case.  */
+      if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+	return pointer_int_sum (PLUS_EXPR, op0, op1);
+      else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
+	return pointer_int_sum (PLUS_EXPR, op1, op0);
+      else
+	common = 1;
+      break;
+
+    case MINUS_EXPR:
+      /* Subtraction of two similar pointers.
+	 We must subtract them as integers, then divide by object size.  */
+      if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
+	  && comp_target_types (type0, type1))
+	return pointer_diff (op0, op1);
+      /* Handle pointer minus int.  Just like pointer plus int.  */
+      else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+	return pointer_int_sum (MINUS_EXPR, op0, op1);
+      else
+	common = 1;
+      break;
+
+    case MULT_EXPR:
+      common = 1;
+      break;
+
+    case TRUNC_DIV_EXPR:
+    case CEIL_DIV_EXPR:
+    case FLOOR_DIV_EXPR:
+    case ROUND_DIV_EXPR:
+    case EXACT_DIV_EXPR:
+      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+	   || code0 == COMPLEX_TYPE)
+	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+	      || code1 == COMPLEX_TYPE))
+	{
+	  if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
+	    resultcode = RDIV_EXPR;
+	  else
+	    /* When dividing two signed integers, you have to promote to int.
+	       E.g. (short) -32868 / (short) -1 doesn't fit in a short.  */
+	    shorten = TREE_UNSIGNED (op0);
+	  common = 1;
+	}
+      break;
+
+    case BIT_AND_EXPR:
+    case BIT_ANDTC_EXPR:
+    case BIT_IOR_EXPR:
+    case BIT_XOR_EXPR:
+      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+	shorten = -1;
+      /* If one operand is a constant, and the other is a short type
+	 that has been converted to an int,
+	 really do the work in the short type and then convert the
+	 result to int.  If we are lucky, the constant will be 0 or 1
+	 in the short type, making the entire operation go away.  */
+      if (TREE_CODE (op0) == INTEGER_CST
+	  && TREE_CODE (op1) == NOP_EXPR
+	  && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
+	  && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
+	{
+	  final_type = result_type;
+	  op1 = TREE_OPERAND (op1, 0);
+	  result_type = TREE_TYPE (op1);
+	}
+      if (TREE_CODE (op1) == INTEGER_CST
+	  && TREE_CODE (op0) == NOP_EXPR
+	  && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
+	  && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
+	{
+	  final_type = result_type;
+	  op0 = TREE_OPERAND (op0, 0);
+	  result_type = TREE_TYPE (op0);
+	}
+      break;
+
+    case TRUNC_MOD_EXPR:
+    case FLOOR_MOD_EXPR:
+      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+	shorten = 1;
+      break;
+
+    case TRUTH_ANDIF_EXPR:
+    case TRUTH_ORIF_EXPR:
+    case TRUTH_AND_EXPR:
+    case TRUTH_OR_EXPR:
+    case TRUTH_XOR_EXPR:
+      if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
+	   || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
+	  && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
+	      || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
+	{
+	  /* Result of these operations is always an int,
+	     but that does not mean the operands should be
+	     converted to ints!  */
+	  result_type = integer_type_node;
+	  op0 = truthvalue_conversion (op0);
+	  op1 = truthvalue_conversion (op1);
+	  converted = 1;
+	}
+      break;
+
+      /* Shift operations: result has same type as first operand;
+	 always convert second operand to int.
+	 Also set SHORT_SHIFT if shifting rightward.  */
+
+    case RSHIFT_EXPR:
+      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+	{
+	  if (TREE_CODE (op1) == INTEGER_CST)
+	    {
+	      if (tree_int_cst_lt (op1, integer_zero_node))
+		warning ("right shift count is negative");
+	      else
+		{
+		  if (TREE_INT_CST_LOW (op1) | TREE_INT_CST_HIGH (op1))
+		    short_shift = 1;
+		  if (TREE_INT_CST_HIGH (op1) != 0
+		      || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
+			  >= TYPE_PRECISION (type0)))
+		    warning ("right shift count >= width of type");
+		}
+	    }
+	  /* Use the type of the value to be shifted.
+	     This is what most traditional C compilers do.  */
+	  result_type = type0;
+	  /* Unless traditional, convert the shift-count to an integer,
+	     regardless of size of value being shifted.  */
+	  if (! flag_traditional)
+	    {
+	      if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+		op1 = convert (integer_type_node, op1);
+	      /* Avoid converting op1 to result_type later.  */
+	      converted = 1;
+	    }
+	}
+      break;
+
+    case LSHIFT_EXPR:
+      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+	{
+	  if (TREE_CODE (op1) == INTEGER_CST)
+	    {
+	      if (tree_int_cst_lt (op1, integer_zero_node))
+		warning ("left shift count is negative");
+	      else if (TREE_INT_CST_HIGH (op1) != 0
+		       || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
+			   >= TYPE_PRECISION (type0)))
+		warning ("left shift count >= width of type");
+	    }
+	  /* Use the type of the value to be shifted.
+	     This is what most traditional C compilers do.  */
+	  result_type = type0;
+	  /* Unless traditional, convert the shift-count to an integer,
+	     regardless of size of value being shifted.  */
+	  if (! flag_traditional)
+	    {
+	      if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+		op1 = convert (integer_type_node, op1);
+	      /* Avoid converting op1 to result_type later.  */
+	      converted = 1;
+	    }
+	}
+      break;
+
+    case RROTATE_EXPR:
+    case LROTATE_EXPR:
+      if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+	{
+	  if (TREE_CODE (op1) == INTEGER_CST)
+	    {
+	      if (tree_int_cst_lt (op1, integer_zero_node))
+		warning ("shift count is negative");
+	      else if (TREE_INT_CST_HIGH (op1) != 0
+		       || ((unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (op1)
+			   >= TYPE_PRECISION (type0)))
+		warning ("shift count >= width of type");
+	    }
+	  /* Use the type of the value to be shifted.
+	     This is what most traditional C compilers do.  */
+	  result_type = type0;
+	  /* Unless traditional, convert the shift-count to an integer,
+	     regardless of size of value being shifted.  */
+	  if (! flag_traditional)
+	    {
+	      if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+		op1 = convert (integer_type_node, op1);
+	      /* Avoid converting op1 to result_type later.  */
+	      converted = 1;
+	    }
+	}
+      break;
+
+    case EQ_EXPR:
+    case NE_EXPR:
+      /* Result of comparison is always int,
+	 but don't convert the args to int!  */
+      result_type = integer_type_node;
+      converted = 1;
+      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+	   || code0 == COMPLEX_TYPE)
+	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+	      || code1 == COMPLEX_TYPE))
+	short_compare = 1;
+      else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
+	{
+	  register tree tt0 = TREE_TYPE (type0);
+	  register tree tt1 = TREE_TYPE (type1);
+	  /* Anything compares with void *.  void * compares with anything.
+	     Otherwise, the targets must be the same.  */
+	  if (comp_target_types (type0, type1))
+	    ;
+	  else if (TYPE_MAIN_VARIANT (tt0) == void_type_node)
+	    {
+	      if (pedantic && !integer_zerop (op0)
+		  && TREE_CODE (tt1) == FUNCTION_TYPE)
+		pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
+	    }
+	  else if (TYPE_MAIN_VARIANT (tt1) == void_type_node)
+	    {
+	      if (pedantic && !integer_zerop (op1)
+		  && TREE_CODE (tt0) == FUNCTION_TYPE)
+		pedwarn ("ANSI C forbids comparison of `void *' with function pointer");
+	    }
+	  else
+	    pedwarn ("comparison of distinct pointer types lacks a cast");
+	}
+      else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
+	       && integer_zerop (op1))
+	op1 = null_pointer_node;
+      else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
+	       && integer_zerop (op0))
+	op0 = null_pointer_node;
+      else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+	{
+	  if (! flag_traditional)
+	    pedwarn ("comparison between pointer and integer");
+	  op1 = convert (TREE_TYPE (op0), op1);
+	}
+      else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
+	{
+	  if (! flag_traditional)
+	    pedwarn ("comparison between pointer and integer");
+	  op0 = convert (TREE_TYPE (op1), op0);
+	}
+      else
+	/* If args are not valid, clear out RESULT_TYPE
+	   to cause an error message later.  */
+	result_type = 0;
+      break;
+
+    case MAX_EXPR:
+    case MIN_EXPR:
+      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+	   || code0 == COMPLEX_TYPE)
+	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+	      || code1 == COMPLEX_TYPE))
+	shorten = 1;
+      else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
+	{
+	  if (! comp_target_types (type0, type1))
+	    pedwarn ("comparison of distinct pointer types lacks a cast");
+	  else if (pedantic 
+		   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
+	    pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
+	  result_type = common_type (type0, type1);
+	}
+      break;
+
+    case LE_EXPR:
+    case GE_EXPR:
+    case LT_EXPR:
+    case GT_EXPR:
+      if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+	   || code0 == COMPLEX_TYPE)
+	  && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+	      || code1 == COMPLEX_TYPE))
+	short_compare = 1;
+      else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
+	{
+	  if (! comp_target_types (type0, type1))
+	    pedwarn ("comparison of distinct pointer types lacks a cast");
+	  else if (pedantic 
+		   && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
+	    pedwarn ("ANSI C forbids ordered comparisons of pointers to functions");
+	  result_type = integer_type_node;
+	}
+      else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
+	       && integer_zerop (op1))
+	{
+	  result_type = integer_type_node;
+	  op1 = null_pointer_node;
+	  if (! flag_traditional)
+	    pedwarn ("ordered comparison of pointer with integer zero");
+	}
+      else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
+	       && integer_zerop (op0))
+	{
+	  result_type = integer_type_node;
+	  op0 = null_pointer_node;
+	  if (pedantic)
+	    pedwarn ("ordered comparison of pointer with integer zero");
+	}
+      else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+	{
+	  result_type = integer_type_node;
+	  if (! flag_traditional)
+	    pedwarn ("comparison between pointer and integer");
+	  op1 = convert (TREE_TYPE (op0), op1);
+	}
+      else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
+	{
+	  result_type = integer_type_node;
+	  if (! flag_traditional)
+	    pedwarn ("comparison between pointer and integer");
+	  op0 = convert (TREE_TYPE (op1), op0);
+	}
+      converted = 1;
+      break;
+    }
+
+  if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
+      &&
+      (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
+    {
+      int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
+
+      if (shorten || common || short_compare)
+	result_type = common_type (type0, type1);
+
+      /* For certain operations (which identify themselves by shorten != 0)
+	 if both args were extended from the same smaller type,
+	 do the arithmetic in that type and then extend.
+
+	 shorten !=0 and !=1 indicates a bitwise operation.
+	 For them, this optimization is safe only if
+	 both args are zero-extended or both are sign-extended.
+	 Otherwise, we might change the result.
+	 Eg, (short)-1 | (unsigned short)-1 is (int)-1
+	 but calculated in (unsigned short) it would be (unsigned short)-1.  */
+
+      if (shorten && none_complex)
+	{
+	  int unsigned0, unsigned1;
+	  tree arg0 = get_narrower (op0, &unsigned0);
+	  tree arg1 = get_narrower (op1, &unsigned1);
+	  /* UNS is 1 if the operation to be done is an unsigned one.  */
+	  int uns = TREE_UNSIGNED (result_type);
+	  tree type;
+
+	  final_type = result_type;
+
+	  /* Handle the case that OP0 (or OP1) does not *contain* a conversion
+	     but it *requires* conversion to FINAL_TYPE.  */
+
+	  if ((TYPE_PRECISION (TREE_TYPE (op0))
+	       == TYPE_PRECISION (TREE_TYPE (arg0)))
+	      && TREE_TYPE (op0) != final_type)
+	    unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
+	  if ((TYPE_PRECISION (TREE_TYPE (op1))
+	       == TYPE_PRECISION (TREE_TYPE (arg1)))
+	      && TREE_TYPE (op1) != final_type)
+	    unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
+
+	  /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
+
+	  /* For bitwise operations, signedness of nominal type
+	     does not matter.  Consider only how operands were extended.  */
+	  if (shorten == -1)
+	    uns = unsigned0;
+
+	  /* Note that in all three cases below we refrain from optimizing
+	     an unsigned operation on sign-extended args.
+	     That would not be valid.  */
+
+	  /* Both args variable: if both extended in same way
+	     from same width, do it in that width.
+	     Do it unsigned if args were zero-extended.  */
+	  if ((TYPE_PRECISION (TREE_TYPE (arg0))
+	       < TYPE_PRECISION (result_type))
+	      && (TYPE_PRECISION (TREE_TYPE (arg1))
+		  == TYPE_PRECISION (TREE_TYPE (arg0)))
+	      && unsigned0 == unsigned1
+	      && (unsigned0 || !uns))
+	    result_type
+	      = signed_or_unsigned_type (unsigned0,
+					 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
+	  else if (TREE_CODE (arg0) == INTEGER_CST
+		   && (unsigned1 || !uns)
+		   && (TYPE_PRECISION (TREE_TYPE (arg1))
+		       < TYPE_PRECISION (result_type))
+		   && (type = signed_or_unsigned_type (unsigned1,
+						       TREE_TYPE (arg1)),
+		       int_fits_type_p (arg0, type)))
+	    result_type = type;
+	  else if (TREE_CODE (arg1) == INTEGER_CST
+		   && (unsigned0 || !uns)
+		   && (TYPE_PRECISION (TREE_TYPE (arg0))
+		       < TYPE_PRECISION (result_type))
+		   && (type = signed_or_unsigned_type (unsigned0,
+						       TREE_TYPE (arg0)),
+		       int_fits_type_p (arg1, type)))
+	    result_type = type;
+	}
+
+      /* Shifts can be shortened if shifting right.  */
+
+      if (short_shift)
+	{
+	  int unsigned_arg;
+	  tree arg0 = get_narrower (op0, &unsigned_arg);
+
+	  final_type = result_type;
+
+	  if (arg0 == op0 && final_type == TREE_TYPE (op0))
+	    unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
+
+	  if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
+	      /* If arg is sign-extended and then unsigned-shifted,
+		 we can simulate this with a signed shift in arg's type
+		 only if the extended result is at least twice as wide
+		 as the arg.  Otherwise, the shift could use up all the
+		 ones made by sign-extension and bring in zeros.
+		 We can't optimize that case at all, but in most machines
+		 it never happens because available widths are 2**N.  */
+	      && (!TREE_UNSIGNED (final_type)
+		  || unsigned_arg
+		  || 2 * TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (result_type)))
+	    {
+	      /* Do an unsigned shift if the operand was zero-extended.  */
+	      result_type
+		= signed_or_unsigned_type (unsigned_arg,
+					   TREE_TYPE (arg0));
+	      /* Convert value-to-be-shifted to that type.  */
+	      if (TREE_TYPE (op0) != result_type)
+		op0 = convert (result_type, op0);
+	      converted = 1;
+	    }
+	}
+
+      /* Comparison operations are shortened too but differently.
+	 They identify themselves by setting short_compare = 1.  */
+
+      if (short_compare && none_complex)
+	{
+	  /* Don't write &op0, etc., because that would prevent op0
+	     from being kept in a register.
+	     Instead, make copies of the our local variables and
+	     pass the copies by reference, then copy them back afterward.  */
+	  tree xop0 = op0, xop1 = op1, xresult_type = result_type;
+	  enum tree_code xresultcode = resultcode;
+	  tree val 
+	    = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
+	  if (val != 0)
+	    return val;
+	  op0 = xop0, op1 = xop1, result_type = xresult_type;
+	  resultcode = xresultcode;
+
+	  if (extra_warnings)
+	    {
+	      tree op0_type = TREE_TYPE (orig_op0);
+	      tree op1_type = TREE_TYPE (orig_op1);
+	      int op0_unsigned = TREE_UNSIGNED (op0_type);
+	      int op1_unsigned = TREE_UNSIGNED (op1_type);
+ 
+	      /* Give warnings for comparisons between signed and unsigned
+		 quantities that will fail.  Do not warn if the signed quantity
+		 is an unsuffixed integer literal (or some static constant
+		 expression involving such literals) and it is positive.
+		 Do not warn if the width of the unsigned quantity is less
+		 than that of the signed quantity, since in this case all
+		 values of the unsigned quantity fit in the signed quantity.
+		 Do not warn if the signed type is the same size as the
+		 result_type since sign extension does not cause trouble in
+		 this case.  */
+	      /* Do the checking based on the original operand trees, so that
+		 casts will be considered, but default promotions won't be.  */
+	      if (op0_unsigned != op1_unsigned
+		  && ((op0_unsigned
+		       && TYPE_PRECISION (op0_type) >= TYPE_PRECISION (op1_type)
+		       && TYPE_PRECISION (op0_type) < TYPE_PRECISION (result_type)
+		       && (TREE_CODE (op1) != INTEGER_CST
+			   || (TREE_CODE (op1) == INTEGER_CST
+			       && INT_CST_LT (op1, integer_zero_node))))
+		      ||
+		      (op1_unsigned
+		       && TYPE_PRECISION (op1_type) >= TYPE_PRECISION (op0_type)
+		       && TYPE_PRECISION (op1_type) < TYPE_PRECISION (result_type)
+		       && (TREE_CODE (op0) != INTEGER_CST
+			   || (TREE_CODE (op0) == INTEGER_CST
+			       && INT_CST_LT (op0, integer_zero_node))))))
+		warning ("comparison between signed and unsigned");
+	    }
+	}
+    }
+
+  /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
+     If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
+     Then the expression will be built.
+     It will be given type FINAL_TYPE if that is nonzero;
+     otherwise, it will be given type RESULT_TYPE.  */
+
+  if (!result_type)
+    {
+      binary_op_error (code);
+      return error_mark_node;
+    }
+
+  if (! converted)
+    {
+      if (TREE_TYPE (op0) != result_type)
+	op0 = convert (result_type, op0); 
+      if (TREE_TYPE (op1) != result_type)
+	op1 = convert (result_type, op1); 
+    }
+
+  {
+    register tree result = build (resultcode, result_type, op0, op1);
+    register tree folded;
+
+    folded = fold (result);
+    if (folded == result)
+      TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
+    if (final_type != 0)
+      return convert (final_type, folded);
+    return folded;
+  }
+}
+
+/* Return a tree for the sum or difference (RESULTCODE says which)
+   of pointer PTROP and integer INTOP.  */
+
+static tree
+pointer_int_sum (resultcode, ptrop, intop)
+     enum tree_code resultcode;
+     register tree ptrop, intop;
+{
+  tree size_exp;
+
+  register tree result;
+  register tree folded;
+
+  /* The result is a pointer of the same type that is being added.  */
+
+  register tree result_type = TREE_TYPE (ptrop);
+
+  if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
+    {
+      if (pedantic || warn_pointer_arith)
+	pedwarn ("pointer of type `void *' used in arithmetic");
+      size_exp = integer_one_node;
+    }
+  else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
+    {
+      if (pedantic || warn_pointer_arith)
+	pedwarn ("pointer to a function used in arithmetic");
+      size_exp = integer_one_node;
+    }
+  else
+    size_exp = c_size_in_bytes (TREE_TYPE (result_type));
+
+  /* If what we are about to multiply by the size of the elements
+     contains a constant term, apply distributive law
+     and multiply that constant term separately.
+     This helps produce common subexpressions.  */
+
+  if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
+      && ! TREE_CONSTANT (intop)
+      && TREE_CONSTANT (TREE_OPERAND (intop, 1))
+      && TREE_CONSTANT (size_exp)
+      /* If the constant comes from pointer subtraction,
+	 skip this optimization--it would cause an error.  */
+      && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE)
+    {
+      enum tree_code subcode = resultcode;
+      tree int_type = TREE_TYPE (intop);
+      if (TREE_CODE (intop) == MINUS_EXPR)
+	subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
+      /* Convert both subexpression types to the type of intop,
+	 because weird cases involving pointer arithmetic
+	 can result in a sum or difference with different type args.  */
+      ptrop = build_binary_op (subcode, ptrop,
+			       convert (int_type, TREE_OPERAND (intop, 1)), 1);
+      intop = convert (int_type, TREE_OPERAND (intop, 0));
+    }
+
+  /* Convert the integer argument to a type the same size as a pointer
+     so the multiply won't overflow spuriously.  */
+
+  if (TYPE_PRECISION (TREE_TYPE (intop)) != POINTER_SIZE)
+    intop = convert (type_for_size (POINTER_SIZE, 0), intop);
+
+  /* Replace the integer argument
+     with a suitable product by the object size.  */
+
+  intop = build_binary_op (MULT_EXPR, intop, size_exp, 1);
+
+  /* Create the sum or difference.  */
+
+  result = build (resultcode, result_type, ptrop, intop);
+
+  folded = fold (result);
+  if (folded == result)
+    TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
+  return folded;
+}
+
+/* Return a tree for the difference of pointers OP0 and OP1.
+   The resulting tree has type int.  */
+
+static tree
+pointer_diff (op0, op1)
+     register tree op0, op1;
+{
+  register tree result, folded;
+  tree restype = ptrdiff_type_node;
+
+  tree target_type = TREE_TYPE (TREE_TYPE (op0));
+
+  if (pedantic || warn_pointer_arith)
+    {
+      if (TREE_CODE (target_type) == VOID_TYPE)
+	pedwarn ("pointer of type `void *' used in subtraction");
+      if (TREE_CODE (target_type) == FUNCTION_TYPE)
+	pedwarn ("pointer to a function used in subtraction");
+    }
+
+  /* First do the subtraction as integers;
+     then drop through to build the divide operator.  */
+
+  op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
+			 convert (restype, op1), 1);
+  /* This generates an error if op1 is pointer to incomplete type.  */
+  if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
+    error ("arithmetic on pointer to an incomplete type");
+  /* This generates an error if op0 is pointer to incomplete type.  */
+  op1 = c_size_in_bytes (target_type);
+
+  /* Divide by the size, in easiest possible way.  */
+
+  result = build (EXACT_DIV_EXPR, restype, op0, op1);
+
+  folded = fold (result);
+  if (folded == result)
+    TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
+  return folded;
+}
+
+/* Construct and perhaps optimize a tree representation
+   for a unary operation.  CODE, a tree_code, specifies the operation
+   and XARG is the operand.  NOCONVERT nonzero suppresses
+   the default promotions (such as from short to int).  */
+
+tree
+build_unary_op (code, xarg, noconvert)
+     enum tree_code code;
+     tree xarg;
+     int noconvert;
+{
+  /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
+  register tree arg = xarg;
+  register tree argtype = 0;
+  register enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
+  char *errstring = NULL;
+  tree val;
+
+  if (typecode == ERROR_MARK)
+    return error_mark_node;
+  if (typecode == ENUMERAL_TYPE)
+    typecode = INTEGER_TYPE;
+
+  switch (code)
+    {
+    case CONVERT_EXPR:
+      /* This is used for unary plus, because a CONVERT_EXPR
+	 is enough to prevent anybody from looking inside for
+	 associativity, but won't generate any code.  */
+      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
+	    || typecode == COMPLEX_TYPE))
+        errstring = "wrong type argument to unary plus";
+      else if (!noconvert)
+	arg = default_conversion (arg);
+      break;
+
+    case NEGATE_EXPR:
+      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
+	    || typecode == COMPLEX_TYPE))
+        errstring = "wrong type argument to unary minus";
+      else if (!noconvert)
+	arg = default_conversion (arg);
+      break;
+
+    case BIT_NOT_EXPR:
+      if (typecode != INTEGER_TYPE)
+        errstring = "wrong type argument to bit-complement";
+      else if (!noconvert)
+	arg = default_conversion (arg);
+      break;
+
+    case ABS_EXPR:
+      if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
+	    || typecode == COMPLEX_TYPE))
+        errstring = "wrong type argument to abs";
+      else if (!noconvert)
+	arg = default_conversion (arg);
+      break;
+
+    case TRUTH_NOT_EXPR:
+      if (typecode != INTEGER_TYPE
+	  && typecode != REAL_TYPE && typecode != POINTER_TYPE
+	  && typecode != COMPLEX_TYPE
+	  /* These will convert to a pointer.  */
+	  && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
+	{
+	  errstring = "wrong type argument to unary exclamation mark";
+	  break;
+	}
+      arg = truthvalue_conversion (arg);
+      return invert_truthvalue (arg);
+
+    case NOP_EXPR:
+      break;
+
+    case REALPART_EXPR:
+      if (TREE_CODE (arg) == COMPLEX_CST)
+	return TREE_REALPART (arg);
+      else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
+	return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
+      else
+	return arg;
+
+    case IMAGPART_EXPR:
+      if (TREE_CODE (arg) == COMPLEX_CST)
+	return TREE_IMAGPART (arg);
+      else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
+	return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
+      else
+	return convert (TREE_TYPE (arg), integer_zero_node);
+      
+    case PREINCREMENT_EXPR:
+    case POSTINCREMENT_EXPR:
+    case PREDECREMENT_EXPR:
+    case POSTDECREMENT_EXPR:
+      /* Handle complex lvalues (when permitted)
+	 by reduction to simpler cases.  */
+
+      val = unary_complex_lvalue (code, arg);
+      if (val != 0)
+	return val;
+
+      /* Increment or decrement the real part of the value,
+	 and don't change the imaginary part.  */
+      if (typecode == COMPLEX_TYPE)
+	{
+	  tree real, imag;
+
+	  arg = stabilize_reference (arg);
+	  real = build_unary_op (REALPART_EXPR, arg, 1);
+	  imag = build_unary_op (IMAGPART_EXPR, arg, 1);
+	  return build (COMPLEX_EXPR, TREE_TYPE (arg),
+			build_unary_op (code, real, 1), imag);
+	}
+
+      /* Report invalid types.  */
+
+      if (typecode != POINTER_TYPE
+	  && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
+	{
+	  if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
+	    errstring ="wrong type argument to increment";
+	  else
+	    errstring ="wrong type argument to decrement";
+	  break;
+	}
+
+      {
+	register tree inc;
+	tree result_type = TREE_TYPE (arg);
+
+	arg = get_unwidened (arg, 0);
+	argtype = TREE_TYPE (arg);
+
+	/* Compute the increment.  */
+
+	if (typecode == POINTER_TYPE)
+	  {
+	    /* If pointer target is an undefined struct,
+	       we just cannot know how to do the arithmetic.  */
+	    if (TYPE_SIZE (TREE_TYPE (result_type)) == 0)
+	      error ("%s of pointer to unknown structure",
+		       ((code == PREINCREMENT_EXPR
+			 || code == POSTINCREMENT_EXPR)
+			? "increment" : "decrement"));
+	    else if ((pedantic || warn_pointer_arith)
+		     && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
+			 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
+	      pedwarn ("wrong type argument to %s",
+		       ((code == PREINCREMENT_EXPR
+			 || code == POSTINCREMENT_EXPR)
+			? "increment" : "decrement"));
+	    inc = c_sizeof_nowarn (TREE_TYPE (result_type));
+	  }
+	else
+	  inc = integer_one_node;
+
+	inc = convert (argtype, inc);
+
+	/* Handle incrementing a cast-expression.  */
+
+	while (1)
+	  switch (TREE_CODE (arg))
+	    {
+	    case NOP_EXPR:
+	    case CONVERT_EXPR:
+	    case FLOAT_EXPR:
+	    case FIX_TRUNC_EXPR:
+	    case FIX_FLOOR_EXPR:
+	    case FIX_ROUND_EXPR:
+	    case FIX_CEIL_EXPR:
+	      pedantic_lvalue_warning (CONVERT_EXPR);
+	      /* If the real type has the same machine representation
+		 as the type it is cast to, we can make better output
+		 by adding directly to the inside of the cast.  */
+	      if ((TREE_CODE (TREE_TYPE (arg))
+		   == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
+		  && (TYPE_MODE (TREE_TYPE (arg))
+		      == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
+		arg = TREE_OPERAND (arg, 0);
+	      else
+		{
+		  tree incremented, modify, value;
+		  arg = stabilize_reference (arg);
+		  if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
+		    value = arg;
+		  else
+		    value = save_expr (arg);
+		  incremented = build (((code == PREINCREMENT_EXPR
+					 || code == POSTINCREMENT_EXPR)
+					? PLUS_EXPR : MINUS_EXPR),
+				       argtype, value, inc);
+		  TREE_SIDE_EFFECTS (incremented) = 1;
+		  modify = build_modify_expr (arg, NOP_EXPR, incremented);
+		  value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
+		  TREE_USED (value) = 1;
+		  return value;
+		}
+	      break;
+
+	    default:
+	      goto give_up;
+	    }
+      give_up:
+
+	/* Complain about anything else that is not a true lvalue.  */
+	if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
+				    || code == POSTINCREMENT_EXPR)
+				   ? "increment" : "decrement")))
+	  return error_mark_node;
+
+	/* Report a read-only lvalue.  */
+	if (TREE_READONLY (arg))
+	  readonly_warning (arg, 
+			    ((code == PREINCREMENT_EXPR
+			      || code == POSTINCREMENT_EXPR)
+			     ? "increment" : "decrement"));
+
+	val = build (code, TREE_TYPE (arg), arg, inc);
+	TREE_SIDE_EFFECTS (val) = 1;
+	val = convert (result_type, val);
+	if (TREE_CODE (val) != code)
+	  TREE_NO_UNUSED_WARNING (val) = 1;
+	return val;
+      }
+
+    case ADDR_EXPR:
+      /* Note that this operation never does default_conversion
+	 regardless of NOCONVERT.  */
+
+      /* Let &* cancel out to simplify resulting code.  */
+      if (TREE_CODE (arg) == INDIRECT_REF)
+	{
+	  /* Don't let this be an lvalue.  */
+	  if (lvalue_p (TREE_OPERAND (arg, 0)))
+	    return non_lvalue (TREE_OPERAND (arg, 0));
+	  return TREE_OPERAND (arg, 0);
+	}
+
+      /* For &x[y], return x+y */
+      if (TREE_CODE (arg) == ARRAY_REF)
+	{
+	  if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
+	    return error_mark_node;
+	  return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
+				  TREE_OPERAND (arg, 1), 1);
+	}
+
+      /* Handle complex lvalues (when permitted)
+	 by reduction to simpler cases.  */
+      val = unary_complex_lvalue (code, arg);
+      if (val != 0)
+	return val;
+
+#if 0 /* Turned off because inconsistent;
+	 float f; *&(int)f = 3.4 stores in int format
+	 whereas (int)f = 3.4 stores in float format.  */
+      /* Address of a cast is just a cast of the address
+	 of the operand of the cast.  */
+      switch (TREE_CODE (arg))
+	{
+	case NOP_EXPR:
+	case CONVERT_EXPR:
+	case FLOAT_EXPR:
+	case FIX_TRUNC_EXPR:
+	case FIX_FLOOR_EXPR:
+	case FIX_ROUND_EXPR:
+	case FIX_CEIL_EXPR:
+	  if (pedantic)
+	    pedwarn ("ANSI C forbids the address of a cast expression");
+	  return convert (build_pointer_type (TREE_TYPE (arg)),
+			  build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0),
+					  0));
+	}
+#endif
+
+      /* Allow the address of a constructor if all the elements
+	 are constant.  */
+      if (TREE_CODE (arg) == CONSTRUCTOR && TREE_CONSTANT (arg))
+	;
+      /* Anything not already handled and not a true memory reference
+	 is an error.  */
+      else if (typecode != FUNCTION_TYPE && !lvalue_or_else (arg, "unary `&'"))
+	return error_mark_node;
+
+      /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
+      argtype = TREE_TYPE (arg);
+      /* If the lvalue is const or volatile,
+	 merge that into the type that the address will point to.  */
+      if (TREE_CODE_CLASS (TREE_CODE (arg)) == 'd'
+	  || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
+	{
+	  if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
+	    argtype = c_build_type_variant (argtype,
+					    TREE_READONLY (arg),
+					    TREE_THIS_VOLATILE (arg));
+	}
+
+      argtype = build_pointer_type (argtype);
+
+      if (mark_addressable (arg) == 0)
+	return error_mark_node;
+
+      {
+	tree addr;
+
+	if (TREE_CODE (arg) == COMPONENT_REF)
+	  {
+	    tree field = TREE_OPERAND (arg, 1);
+
+	    addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
+
+	    if (DECL_BIT_FIELD (field))
+	      {
+		error ("attempt to take address of bit-field structure member `%s'",
+		       IDENTIFIER_POINTER (DECL_NAME (field)));
+		return error_mark_node;
+	      }
+
+	    addr = convert (argtype, addr);
+
+	    if (! integer_zerop (DECL_FIELD_BITPOS (field)))
+	      {
+		tree offset
+		  = size_binop (EASY_DIV_EXPR, DECL_FIELD_BITPOS (field),
+				size_int (BITS_PER_UNIT));
+		int flag = TREE_CONSTANT (addr);
+		addr = fold (build (PLUS_EXPR, argtype,
+				    addr, convert (argtype, offset)));
+		TREE_CONSTANT (addr) = flag;
+	      }
+	  }
+	else
+	  addr = build1 (code, argtype, arg);
+
+	/* Address of a static or external variable or
+	   file-scope function counts as a constant.  */
+	if (staticp (arg)
+	    && ! (TREE_CODE (arg) == FUNCTION_DECL
+		  && DECL_CONTEXT (arg) != 0))
+	  TREE_CONSTANT (addr) = 1;
+	return addr;
+      }
+    }
+
+  if (!errstring)
+    {
+      if (argtype == 0)
+	argtype = TREE_TYPE (arg);
+      return fold (build1 (code, argtype, arg));
+    }
+
+  error (errstring);
+  return error_mark_node;
+}
+
+#if 0
+/* If CONVERSIONS is a conversion expression or a nested sequence of such,
+   convert ARG with the same conversions in the same order
+   and return the result.  */
+
+static tree
+convert_sequence (conversions, arg)
+     tree conversions;
+     tree arg;
+{
+  switch (TREE_CODE (conversions))
+    {
+    case NOP_EXPR:
+    case CONVERT_EXPR:
+    case FLOAT_EXPR:
+    case FIX_TRUNC_EXPR:
+    case FIX_FLOOR_EXPR:
+    case FIX_ROUND_EXPR:
+    case FIX_CEIL_EXPR:
+      return convert (TREE_TYPE (conversions),
+		      convert_sequence (TREE_OPERAND (conversions, 0),
+					arg));
+
+    default:
+      return arg;
+    }
+}
+#endif /* 0 */
+
+/* Return nonzero if REF is an lvalue valid for this language.
+   Lvalues can be assigned, unless their type has TYPE_READONLY.
+   Lvalues can have their address taken, unless they have DECL_REGISTER.  */
+
+int
+lvalue_p (ref)
+     tree ref;
+{
+  register enum tree_code code = TREE_CODE (ref);
+
+  switch (code)
+    {
+    case REALPART_EXPR:
+    case IMAGPART_EXPR:
+    case COMPONENT_REF:
+      return lvalue_p (TREE_OPERAND (ref, 0));
+
+    case STRING_CST:
+      return 1;
+
+    case INDIRECT_REF:
+    case ARRAY_REF:
+    case VAR_DECL:
+    case PARM_DECL:
+    case RESULT_DECL:
+    case ERROR_MARK:
+      if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
+	  && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
+	return 1;
+      break;
+    }
+  return 0;
+}
+
+/* Return nonzero if REF is an lvalue valid for this language;
+   otherwise, print an error message and return zero.  */
+
+int
+lvalue_or_else (ref, string)
+     tree ref;
+     char *string;
+{
+  int win = lvalue_p (ref);
+  if (! win)
+    error ("invalid lvalue in %s", string);
+  return win;
+}
+
+/* Apply unary lvalue-demanding operator CODE to the expression ARG
+   for certain kinds of expressions which are not really lvalues
+   but which we can accept as lvalues.
+
+   If ARG is not a kind of expression we can handle, return zero.  */
+   
+static tree
+unary_complex_lvalue (code, arg)
+     enum tree_code code;
+     tree arg;
+{
+  /* Handle (a, b) used as an "lvalue".  */
+  if (TREE_CODE (arg) == COMPOUND_EXPR)
+    {
+      tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
+      pedantic_lvalue_warning (COMPOUND_EXPR);
+      return build (COMPOUND_EXPR, TREE_TYPE (real_result),
+		    TREE_OPERAND (arg, 0), real_result);
+    }
+
+  /* Handle (a ? b : c) used as an "lvalue".  */
+  if (TREE_CODE (arg) == COND_EXPR)
+    {
+      pedantic_lvalue_warning (COND_EXPR);
+      return (build_conditional_expr
+	      (TREE_OPERAND (arg, 0),
+	       build_unary_op (code, TREE_OPERAND (arg, 1), 0),
+	       build_unary_op (code, TREE_OPERAND (arg, 2), 0)));
+    }
+
+  return 0;
+}
+
+/* If pedantic, warn about improper lvalue.   CODE is either COND_EXPR
+   COMPOUND_EXPR, or CONVERT_EXPR (for casts).  */
+
+static void
+pedantic_lvalue_warning (code)
+     enum tree_code code;
+{
+  if (pedantic)
+    pedwarn ("ANSI C forbids use of %s expressions as lvalues",
+	     code == COND_EXPR ? "conditional"
+	     : code == COMPOUND_EXPR ? "compound" : "cast");
+}
+
+/* Warn about storing in something that is `const'.  */
+
+void
+readonly_warning (arg, string)
+     tree arg;
+     char *string;
+{
+  char buf[80];
+  strcpy (buf, string);
+
+  /* Forbid assignments to iterators.  */
+  if (TREE_CODE (arg) == VAR_DECL && ITERATOR_P (arg))
+    {
+      strcat (buf, " of iterator `%s'");
+      pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
+    }
+
+  if (TREE_CODE (arg) == COMPONENT_REF)
+    {
+      if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
+	readonly_warning (TREE_OPERAND (arg, 0), string);
+      else
+	{
+	  strcat (buf, " of read-only member `%s'");
+	  pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
+	}
+    }
+  else if (TREE_CODE (arg) == VAR_DECL)
+    {
+      strcat (buf, " of read-only variable `%s'");
+      pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
+    }
+  else
+    {
+      pedwarn ("%s of read-only location", buf);
+    }
+}
+
+/* Mark EXP saying that we need to be able to take the
+   address of it; it should not be allocated in a register.
+   Value is 1 if successful.  */
+
+int
+mark_addressable (exp)
+     tree exp;
+{
+  register tree x = exp;
+  while (1)
+    switch (TREE_CODE (x))
+      {
+      case ADDR_EXPR:
+      case COMPONENT_REF:
+      case ARRAY_REF:
+	x = TREE_OPERAND (x, 0);
+	break;
+
+      case CONSTRUCTOR:
+	TREE_ADDRESSABLE (x) = 1;
+	return 1;
+
+      case VAR_DECL:
+      case CONST_DECL:
+      case PARM_DECL:
+      case RESULT_DECL:
+	if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
+	    && DECL_NONLOCAL (x))
+	  {
+	    if (TREE_PUBLIC (x))
+	      {
+		error ("global register variable `%s' used in nested function",
+		       IDENTIFIER_POINTER (DECL_NAME (x)));
+		return 0;
+	      }
+	    pedwarn ("register variable `%s' used in nested function",
+		     IDENTIFIER_POINTER (DECL_NAME (x)));
+	  }
+	else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
+	  {
+	    if (TREE_PUBLIC (x))
+	      {
+		error ("address of global register variable `%s' requested",
+		       IDENTIFIER_POINTER (DECL_NAME (x)));
+		return 0;
+	      }
+	    pedwarn ("address of register variable `%s' requested",
+		     IDENTIFIER_POINTER (DECL_NAME (x)));
+	  }
+	put_var_into_stack (x);
+
+	/* drops in */
+      case FUNCTION_DECL:
+	TREE_ADDRESSABLE (x) = 1;
+#if 0  /* poplevel deals with this now.  */
+	if (DECL_CONTEXT (x) == 0)
+	  TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
+#endif
+
+      default:
+	return 1;
+    }
+}
+
+/* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
+
+tree
+build_conditional_expr (ifexp, op1, op2)
+     tree ifexp, op1, op2;
+{
+  register tree type1;
+  register tree type2;
+  register enum tree_code code1;
+  register enum tree_code code2;
+  register tree result_type = NULL;
+
+  /* If second operand is omitted, it is the same as the first one;
+     make sure it is calculated only once.  */
+  if (op1 == 0)
+    {
+      if (pedantic)
+	pedwarn ("ANSI C forbids omitting the middle term of a ?: expression");
+      ifexp = op1 = save_expr (ifexp);
+    }
+
+  ifexp = truthvalue_conversion (default_conversion (ifexp));
+
+#if 0 /* Produces wrong result if within sizeof.  */
+  /* Don't promote the operands separately if they promote
+     the same way.  Return the unpromoted type and let the combined
+     value get promoted if necessary.  */
+
+  if (TREE_TYPE (op1) == TREE_TYPE (op2)
+      && TREE_CODE (TREE_TYPE (op1)) != ARRAY_TYPE
+      && TREE_CODE (TREE_TYPE (op1)) != ENUMERAL_TYPE
+      && TREE_CODE (TREE_TYPE (op1)) != FUNCTION_TYPE)
+    {
+      if (TREE_CODE (ifexp) == INTEGER_CST)
+	return (integer_zerop (ifexp) ? op2 : op1);
+
+      return fold (build (COND_EXPR, TREE_TYPE (op1), ifexp, op1, op2));
+    }
+#endif
+
+  /* Promote both alternatives.  */
+
+  if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
+    op1 = default_conversion (op1);
+  if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
+    op2 = default_conversion (op2);
+
+  if (TREE_CODE (ifexp) == ERROR_MARK
+      || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
+      || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
+    return error_mark_node;
+
+  type1 = TREE_TYPE (op1);
+  code1 = TREE_CODE (type1);
+  type2 = TREE_TYPE (op2);
+  code2 = TREE_CODE (type2);
+      
+  /* Quickly detect the usual case where op1 and op2 have the same type
+     after promotion.  */
+  if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
+    {
+      if (type1 == type2)
+	result_type = type1;
+      else
+	result_type = TYPE_MAIN_VARIANT (type1);
+    }
+  else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE)
+           && (code2 == INTEGER_TYPE || code2 == REAL_TYPE))
+    {
+      result_type = common_type (type1, type2);
+    }
+  else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
+    {
+      if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
+	pedwarn ("ANSI C forbids conditional expr with only one void side");
+      result_type = void_type_node;
+    }
+  else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
+    {
+      if (comp_target_types (type1, type2))
+	result_type = common_type (type1, type2);
+      else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node)
+	result_type = qualify_type (type2, type1);
+      else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node)
+	result_type = qualify_type (type1, type2);
+      else if (TYPE_MAIN_VARIANT (TREE_TYPE (type1)) == void_type_node)
+	{
+	  if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
+	    pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
+	  result_type = qualify_type (type1, type2);
+	}
+      else if (TYPE_MAIN_VARIANT (TREE_TYPE (type2)) == void_type_node)
+	{
+	  if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
+	    pedwarn ("ANSI C forbids conditional expr between `void *' and function pointer");
+	  result_type = qualify_type (type2, type1);
+	}
+      else
+	{
+	  pedwarn ("pointer type mismatch in conditional expression");
+	  result_type = build_pointer_type (void_type_node);
+	}
+    }
+  else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
+    {
+      if (! integer_zerop (op2))
+	pedwarn ("pointer/integer type mismatch in conditional expression");
+      else
+	{
+	  op2 = null_pointer_node;
+#if 0  /* The spec seems to say this is permitted.  */
+	  if (pedantic && TREE_CODE (type1) == FUNCTION_TYPE)
+	    pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
+#endif
+	}
+      result_type = type1;
+    }
+  else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
+    {
+      if (!integer_zerop (op1))
+	pedwarn ("pointer/integer type mismatch in conditional expression");
+      else
+	{
+	  op1 = null_pointer_node;
+#if 0  /* The spec seems to say this is permitted.  */
+	  if (pedantic && TREE_CODE (type2) == FUNCTION_TYPE)
+	    pedwarn ("ANSI C forbids conditional expr between 0 and function pointer");
+#endif
+	}
+      result_type = type2;
+    }
+
+  if (!result_type)
+    {
+      if (flag_cond_mismatch)
+	result_type = void_type_node;
+      else
+	{
+	  error ("type mismatch in conditional expression");
+	  return error_mark_node;
+	}
+    }
+
+  /* Merge const and volatile flags of the incoming types.  */
+  result_type
+    = build_type_variant (result_type,
+			  TREE_READONLY (op1) || TREE_READONLY (op2),
+			  TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
+
+  if (result_type != TREE_TYPE (op1))
+    op1 = convert_and_check (result_type, op1);
+  if (result_type != TREE_TYPE (op2))
+    op2 = convert_and_check (result_type, op2);
+    
+#if 0
+  if (code1 == RECORD_TYPE || code1 == UNION_TYPE)
+    {
+      result_type = TREE_TYPE (op1);
+      if (TREE_CONSTANT (ifexp))
+	return (integer_zerop (ifexp) ? op2 : op1);
+
+      if (TYPE_MODE (result_type) == BLKmode)
+	{
+	  register tree tempvar
+	    = build_decl (VAR_DECL, NULL_TREE, result_type);
+	  register tree xop1 = build_modify_expr (tempvar, op1);
+	  register tree xop2 = build_modify_expr (tempvar, op2);
+	  register tree result = fold (build (COND_EXPR, result_type,
+					      ifexp, xop1, xop2));
+
+	  layout_decl (tempvar, TYPE_ALIGN (result_type));
+	  /* No way to handle variable-sized objects here.
+	     I fear that the entire handling of BLKmode conditional exprs
+	     needs to be redone.  */
+	  if (TREE_CODE (DECL_SIZE (tempvar)) != INTEGER_CST)
+	    abort ();
+	  DECL_RTL (tempvar)
+	    = assign_stack_local (DECL_MODE (tempvar),
+				  (TREE_INT_CST_LOW (DECL_SIZE (tempvar))
+				   + BITS_PER_UNIT - 1)
+				  / BITS_PER_UNIT,
+				  0);
+
+	  TREE_SIDE_EFFECTS (result)
+	    = TREE_SIDE_EFFECTS (ifexp) | TREE_SIDE_EFFECTS (op1)
+	      | TREE_SIDE_EFFECTS (op2);
+	  return build (COMPOUND_EXPR, result_type, result, tempvar);
+	}
+    }
+#endif /* 0 */
+    
+  if (TREE_CODE (ifexp) == INTEGER_CST)
+    return integer_zerop (ifexp) ? op2 : op1;
+
+  return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
+}
+
+/* Given a list of expressions, return a compound expression
+   that performs them all and returns the value of the last of them.  */
+
+tree
+build_compound_expr (list)
+     tree list;
+{
+  return internal_build_compound_expr (list, TRUE);
+}
+
+static tree
+internal_build_compound_expr (list, first_p)
+     tree list;
+     int first_p;
+{
+  register tree rest;
+
+  if (TREE_CHAIN (list) == 0)
+    {
+#if 0 /* If something inside inhibited lvalueness, we should not override.  */
+      /* Consider (x, y+0), which is not an lvalue since y+0 is not.  */
+
+      /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+      if (TREE_CODE (list) == NON_LVALUE_EXPR)
+	list = TREE_OPERAND (list, 0);
+#endif
+
+      /* Don't let (0, 0) be null pointer constant.  */
+      if (!first_p && integer_zerop (TREE_VALUE (list)))
+	return non_lvalue (TREE_VALUE (list));
+      return TREE_VALUE (list);
+    }
+
+  if (TREE_CHAIN (list) != 0 && TREE_CHAIN (TREE_CHAIN (list)) == 0)
+    {
+      /* Convert arrays to pointers when there really is a comma operator.  */
+      if (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (list)))) == ARRAY_TYPE)
+	TREE_VALUE (TREE_CHAIN (list))
+	  = default_conversion (TREE_VALUE (TREE_CHAIN (list)));
+    }
+
+  rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
+
+  /* When pedantic, a compound expression can be neither an lvalue
+     nor an integer constant expression.  */
+  if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)) && ! pedantic)
+    return rest;
+
+  return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
+}
+
+/* Build an expression representing a cast to type TYPE of expression EXPR.  */
+
+tree
+build_c_cast (type, expr)
+     register tree type;
+     tree expr;
+{
+  register tree value = expr;
+  
+  if (type == error_mark_node || expr == error_mark_node)
+    return error_mark_node;
+  type = TYPE_MAIN_VARIANT (type);
+
+#if 0
+  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+  if (TREE_CODE (value) == NON_LVALUE_EXPR)
+    value = TREE_OPERAND (value, 0);
+#endif
+
+  if (TREE_CODE (type) == ARRAY_TYPE)
+    {
+      error ("cast specifies array type");
+      return error_mark_node;
+    }
+
+  if (TREE_CODE (type) == FUNCTION_TYPE)
+    {
+      error ("cast specifies function type");
+      return error_mark_node;
+    }
+
+  if (type == TREE_TYPE (value))
+    {
+      if (pedantic)
+	{
+	  if (TREE_CODE (type) == RECORD_TYPE
+	      || TREE_CODE (type) == UNION_TYPE)
+	    pedwarn ("ANSI C forbids casting nonscalar to the same type");
+	}
+    }
+  else if (TREE_CODE (type) == UNION_TYPE)
+    {
+      tree field;
+      for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+	if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
+		       TYPE_MAIN_VARIANT (TREE_TYPE (value))))
+	  break;
+
+      if (field)
+	{
+	  char *name;
+	  tree nvalue;
+
+	  if (pedantic)
+	    pedwarn ("ANSI C forbids casts to union type");
+	  if (TYPE_NAME (type) != 0)
+	    {
+	      if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
+		name = IDENTIFIER_POINTER (TYPE_NAME (type));
+	      else
+		name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
+	    }
+	  else
+	    name = "";
+	  return digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE,
+					      build_tree_list (field, value)),
+			      NULL_PTR, 0, 0, name);
+	}
+      error ("cast to union type from type not present in union");
+      return error_mark_node;
+    }
+  else
+    {
+      tree otype;
+
+      /* If casting to void, avoid the error that would come
+	 from default_conversion in the case of a non-lvalue array.  */
+      if (type == void_type_node)
+	return build1 (CONVERT_EXPR, type, value);
+
+      /* Convert functions and arrays to pointers,
+	 but don't convert any other types.  */
+      if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
+	  || TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE)
+	value = default_conversion (value);
+      otype = TREE_TYPE (value);
+
+      /* Optionally warn about potentially worrisome casts.  */
+
+      if (warn_cast_qual
+	  && TREE_CODE (type) == POINTER_TYPE
+	  && TREE_CODE (otype) == POINTER_TYPE)
+	{
+	  if (TYPE_VOLATILE (TREE_TYPE (otype))
+	      && ! TYPE_VOLATILE (TREE_TYPE (type)))
+	    pedwarn ("cast discards `volatile' from pointer target type");
+	  if (TYPE_READONLY (TREE_TYPE (otype))
+	      && ! TYPE_READONLY (TREE_TYPE (type)))
+	    pedwarn ("cast discards `const' from pointer target type");
+	}
+
+      /* Warn about possible alignment problems.  */
+      if (STRICT_ALIGNMENT && warn_cast_align
+	  && TREE_CODE (type) == POINTER_TYPE
+	  && TREE_CODE (otype) == POINTER_TYPE
+	  && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
+	  && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
+	  && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
+	warning ("cast increases required alignment of target type");
+
+      if (TREE_CODE (type) == INTEGER_TYPE
+	  && TREE_CODE (otype) == POINTER_TYPE
+	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
+	  && !TREE_CONSTANT (value))
+	warning ("cast from pointer to integer of different size");
+
+      if (TREE_CODE (type) == POINTER_TYPE
+	  && TREE_CODE (otype) == INTEGER_TYPE
+	  && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
+#if 0
+	  /* Don't warn about converting 0 to pointer,
+	     provided the 0 was explicit--not cast or made by folding.  */
+	  && !(TREE_CODE (value) == INTEGER_CST && integer_zerop (value))
+#endif
+	  /* Don't warn about converting any constant.  */
+	  && !TREE_CONSTANT (value))
+	warning ("cast to pointer from integer of different size");
+
+      value = convert (type, value);
+
+      /* Ignore any integer overflow caused by the cast.  */
+      if (TREE_CODE (value) == INTEGER_CST)
+	TREE_CONSTANT_OVERFLOW (value) = 0;
+    }
+
+  if (value == expr && pedantic)
+    {
+      /* If pedantic, don't let a cast be an lvalue.  */
+      return non_lvalue (value);
+    }
+  return value;
+}
+
+/* Build an assignment expression of lvalue LHS from value RHS.
+   MODIFYCODE is the code for a binary operator that we use
+   to combine the old value of LHS with RHS to get the new value.
+   Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
+
+tree
+build_modify_expr (lhs, modifycode, rhs)
+     tree lhs, rhs;
+     enum tree_code modifycode;
+{
+  register tree result;
+  tree newrhs;
+  tree lhstype = TREE_TYPE (lhs);
+  tree olhstype = lhstype;
+
+  /* Types that aren't fully specified cannot be used in assignments.  */
+  lhs = require_complete_type (lhs);
+
+  /* Avoid duplicate error messages from operands that had errors.  */
+  if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
+    return error_mark_node;
+
+  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+  /* Do not use STRIP_NOPS here.  We do not want an enumerator
+     whose value is 0 to count as a null pointer constant.  */
+  if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
+    rhs = TREE_OPERAND (rhs, 0);
+
+  newrhs = rhs;
+
+  /* Handle control structure constructs used as "lvalues".  */
+
+  switch (TREE_CODE (lhs))
+    {
+      /* Handle (a, b) used as an "lvalue".  */
+    case COMPOUND_EXPR:
+      pedantic_lvalue_warning (COMPOUND_EXPR);
+      return build (COMPOUND_EXPR, lhstype,
+		    TREE_OPERAND (lhs, 0),
+		    build_modify_expr (TREE_OPERAND (lhs, 1),
+				       modifycode, rhs));
+
+      /* Handle (a ? b : c) used as an "lvalue".  */
+    case COND_EXPR:
+      pedantic_lvalue_warning (COND_EXPR);
+      rhs = save_expr (rhs);
+      {
+	/* Produce (a ? (b = rhs) : (c = rhs))
+	   except that the RHS goes through a save-expr
+	   so the code to compute it is only emitted once.  */
+	tree cond
+	  = build_conditional_expr (TREE_OPERAND (lhs, 0),
+				    build_modify_expr (TREE_OPERAND (lhs, 1),
+						       modifycode, rhs),
+				    build_modify_expr (TREE_OPERAND (lhs, 2),
+						       modifycode, rhs));
+	/* Make sure the code to compute the rhs comes out
+	   before the split.  */
+	return build (COMPOUND_EXPR, TREE_TYPE (lhs),
+		      /* But cast it to void to avoid an "unused" error.  */
+		      convert (void_type_node, rhs), cond);
+      }
+    }
+
+  /* If a binary op has been requested, combine the old LHS value with the RHS
+     producing the value we should actually store into the LHS.  */
+
+  if (modifycode != NOP_EXPR)
+    {
+      lhs = stabilize_reference (lhs);
+      newrhs = build_binary_op (modifycode, lhs, rhs, 1);
+    }
+
+  /* Handle a cast used as an "lvalue".
+     We have already performed any binary operator using the value as cast.
+     Now convert the result to the cast type of the lhs,
+     and then true type of the lhs and store it there;
+     then convert result back to the cast type to be the value
+     of the assignment.  */
+
+  switch (TREE_CODE (lhs))
+    {
+    case NOP_EXPR:
+    case CONVERT_EXPR:
+    case FLOAT_EXPR:
+    case FIX_TRUNC_EXPR:
+    case FIX_FLOOR_EXPR:
+    case FIX_ROUND_EXPR:
+    case FIX_CEIL_EXPR:
+      if (TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE
+	  || TREE_CODE (TREE_TYPE (newrhs)) == FUNCTION_TYPE)
+	newrhs = default_conversion (newrhs);
+      {
+	tree inner_lhs = TREE_OPERAND (lhs, 0);
+	tree result;
+	result = build_modify_expr (inner_lhs, NOP_EXPR,
+				    convert (TREE_TYPE (inner_lhs),
+					     convert (lhstype, newrhs)));
+	pedantic_lvalue_warning (CONVERT_EXPR);
+	return convert (TREE_TYPE (lhs), result);
+      }
+    }
+
+  /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
+     Reject anything strange now.  */
+
+  if (!lvalue_or_else (lhs, "assignment"))
+    return error_mark_node;
+
+  /* Warn about storing in something that is `const'.  */
+
+  if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
+      || ((TREE_CODE (lhstype) == RECORD_TYPE
+	   || TREE_CODE (lhstype) == UNION_TYPE)
+	  && C_TYPE_FIELDS_READONLY (lhstype)))
+    readonly_warning (lhs, "assignment");
+
+  /* If storing into a structure or union member,
+     it has probably been given type `int'.
+     Compute the type that would go with
+     the actual amount of storage the member occupies.  */
+
+  if (TREE_CODE (lhs) == COMPONENT_REF
+      && (TREE_CODE (lhstype) == INTEGER_TYPE
+	  || TREE_CODE (lhstype) == REAL_TYPE
+	  || TREE_CODE (lhstype) == ENUMERAL_TYPE))
+    lhstype = TREE_TYPE (get_unwidened (lhs, 0));
+
+  /* If storing in a field that is in actuality a short or narrower than one,
+     we must store in the field in its actual type.  */
+
+  if (lhstype != TREE_TYPE (lhs))
+    {
+      lhs = copy_node (lhs);
+      TREE_TYPE (lhs) = lhstype;
+    }
+
+  /* Convert new value to destination type.  */
+
+  newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
+				   NULL_TREE, NULL_TREE, 0);
+  if (TREE_CODE (newrhs) == ERROR_MARK)
+    return error_mark_node;
+
+  result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
+  TREE_SIDE_EFFECTS (result) = 1;
+
+  /* If we got the LHS in a different type for storing in,
+     convert the result back to the nominal type of LHS
+     so that the value we return always has the same type
+     as the LHS argument.  */
+
+  if (olhstype == TREE_TYPE (result))
+    return result;
+  return convert_for_assignment (olhstype, result, "assignment",
+				 NULL_TREE, NULL_TREE, 0);
+}
+
+/* Convert value RHS to type TYPE as preparation for an assignment
+   to an lvalue of type TYPE.
+   The real work of conversion is done by `convert'.
+   The purpose of this function is to generate error messages
+   for assignments that are not allowed in C.
+   ERRTYPE is a string to use in error messages:
+   "assignment", "return", etc.  If it is null, this is parameter passing
+   for a function call (and different error messages are output).  Otherwise,
+   it may be a name stored in the spelling stack and interpreted by
+   get_spelling.
+
+   FUNNAME is the name of the function being called,
+   as an IDENTIFIER_NODE, or null.
+   PARMNUM is the number of the argument, for printing in error messages.  */
+
+static tree
+convert_for_assignment (type, rhs, errtype, fundecl, funname, parmnum)
+     tree type, rhs;
+     char *errtype;
+     tree fundecl, funname;
+     int parmnum;
+{
+  register enum tree_code codel = TREE_CODE (type);
+  register tree rhstype;
+  register enum tree_code coder;
+
+  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+  /* Do not use STRIP_NOPS here.  We do not want an enumerator
+     whose value is 0 to count as a null pointer constant.  */
+  if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
+    rhs = TREE_OPERAND (rhs, 0);
+
+  if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
+      || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
+    rhs = default_conversion (rhs);
+
+  rhstype = TREE_TYPE (rhs);
+  coder = TREE_CODE (rhstype);
+
+  if (coder == ERROR_MARK)
+    return error_mark_node;
+
+  if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
+    {
+      overflow_warning (rhs);
+      /* Check for Objective-C protocols.  This will issue a warning if
+	 there are protocol violations.  No need to use the return value.  */
+      maybe_objc_comptypes (type, rhstype, 0);
+      return rhs;
+    }
+
+  if (coder == VOID_TYPE)
+    {
+      error ("void value not ignored as it ought to be");
+      return error_mark_node;
+    }
+  /* Arithmetic types all interconvert, and enum is treated like int.  */
+  if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE
+       || codel == COMPLEX_TYPE)
+       &&
+      (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE
+       || codel == COMPLEX_TYPE))
+    /* Don't use convert_and_check here.  If the input has type int
+       and did not overflow, and we are converting it here to a short,
+       we don't want an error.  A warning would be okay, but it's too risky now
+       to add an option to convert_and_check to get just warnings.  */
+    return convert (type, rhs);
+  /* Conversion to a union from its member types.  */
+  else if (codel == UNION_TYPE)
+    {
+      tree memb_types;
+      for (memb_types = TYPE_FIELDS (type); memb_types;
+	   memb_types = TREE_CHAIN (memb_types))
+	{
+	  if (comptypes (TREE_TYPE (memb_types), TREE_TYPE (rhs)))
+	    {
+	      if (pedantic
+		  && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl)))
+		pedwarn ("ANSI C prohibits argument conversion to union type");
+	      return build1 (NOP_EXPR, type, rhs);
+	    }
+	  else if (coder == POINTER_TYPE
+		   && TREE_CODE (TREE_TYPE (memb_types)) == POINTER_TYPE)
+	    {
+	      tree memb_type = TREE_TYPE (memb_types);
+	      register tree ttl = TREE_TYPE (memb_type);
+	      register tree ttr = TREE_TYPE (rhstype);
+
+	      /* Any non-function converts to a [const][volatile] void *
+		 and vice versa; otherwise, targets must be the same.
+		 Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
+	      if (TYPE_MAIN_VARIANT (ttl) == void_type_node
+		  || TYPE_MAIN_VARIANT (ttr) == void_type_node
+		  || comp_target_types (memb_type, rhstype))
+		{
+		  /* Const and volatile mean something different for function types,
+		     so the usual warnings are not appropriate.  */
+		  if (TREE_CODE (ttr) != FUNCTION_TYPE
+		      || TREE_CODE (ttl) != FUNCTION_TYPE)
+		    {
+		      if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
+			warn_for_assignment ("%s discards `const' from pointer target type",
+					     get_spelling (errtype), funname, parmnum);
+		      if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
+			warn_for_assignment ("%s discards `volatile' from pointer target type",
+					     get_spelling (errtype), funname, parmnum);
+		    }
+		  else
+		    {
+		      /* Because const and volatile on functions are restrictions
+			 that say the function will not do certain things,
+			 it is okay to use a const or volatile function
+			 where an ordinary one is wanted, but not vice-versa.  */
+		      if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
+			warn_for_assignment ("%s makes `const *' function pointer from non-const",
+					     get_spelling (errtype), funname, parmnum);
+		      if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
+			warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
+					     get_spelling (errtype), funname, parmnum);
+		    }
+		  if (pedantic
+		      && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl)))
+		    pedwarn ("ANSI C prohibits argument conversion to union type");
+		  return build1 (NOP_EXPR, type, rhs);
+		}
+	    }
+	}
+    }
+  /* Conversions among pointers */
+  else if (codel == POINTER_TYPE && coder == POINTER_TYPE)
+    {
+      register tree ttl = TREE_TYPE (type);
+      register tree ttr = TREE_TYPE (rhstype);
+
+      /* Any non-function converts to a [const][volatile] void *
+	 and vice versa; otherwise, targets must be the same.
+	 Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
+      if (TYPE_MAIN_VARIANT (ttl) == void_type_node
+	  || TYPE_MAIN_VARIANT (ttr) == void_type_node
+	  || comp_target_types (type, rhstype))
+	{
+	  if (pedantic
+	      && ((TYPE_MAIN_VARIANT (ttl) == void_type_node
+		   && TREE_CODE (ttr) == FUNCTION_TYPE)
+		  ||
+		  (TYPE_MAIN_VARIANT (ttr) == void_type_node
+		   && !integer_zerop (rhs)
+		   && TREE_CODE (ttl) == FUNCTION_TYPE)))
+	    warn_for_assignment ("ANSI forbids %s between function pointer and `void *'",
+				 get_spelling (errtype), funname, parmnum);
+	  /* Const and volatile mean something different for function types,
+	     so the usual warnings are not appropriate.  */
+	  else if (TREE_CODE (ttr) != FUNCTION_TYPE
+		   || TREE_CODE (ttl) != FUNCTION_TYPE)
+	    {
+	      if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
+		warn_for_assignment ("%s discards `const' from pointer target type",
+				     get_spelling (errtype), funname, parmnum);
+	      if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
+		warn_for_assignment ("%s discards `volatile' from pointer target type",
+				     get_spelling (errtype), funname, parmnum);
+	    }
+	  else
+	    {
+	      /* Because const and volatile on functions are restrictions
+		 that say the function will not do certain things,
+		 it is okay to use a const or volatile function
+		 where an ordinary one is wanted, but not vice-versa.  */
+	      if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
+		warn_for_assignment ("%s makes `const *' function pointer from non-const",
+				     get_spelling (errtype), funname, parmnum);
+	      if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
+		warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
+				     get_spelling (errtype), funname, parmnum);
+	    }
+	}
+      else if (unsigned_type (TYPE_MAIN_VARIANT (ttl))
+	       == unsigned_type (TYPE_MAIN_VARIANT (ttr)))
+	{
+	  if (pedantic)
+	    warn_for_assignment ("pointer targets in %s differ in signedness",
+				 get_spelling (errtype), funname, parmnum);
+	}
+      else
+	warn_for_assignment ("%s from incompatible pointer type",
+			     get_spelling (errtype), funname, parmnum);
+      return convert (type, rhs);
+    }
+  else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
+    {
+      /* An explicit constant 0 can convert to a pointer,
+	 but not a 0 that results from casting or folding.  */
+      if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs)))
+	{
+	  warn_for_assignment ("%s makes pointer from integer without a cast",
+			       get_spelling (errtype), funname, parmnum);
+	  return convert (type, rhs);
+	}
+      return null_pointer_node;
+    }
+  else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
+    {
+      warn_for_assignment ("%s makes integer from pointer without a cast",
+			   get_spelling (errtype), funname, parmnum);
+      return convert (type, rhs);
+    }
+
+  if (!errtype)
+    {
+      if (funname)
+ 	{
+ 	  tree selector = maybe_building_objc_message_expr ();
+ 
+ 	  if (selector && parmnum > 2)
+ 	    error ("incompatible type for argument %d of `%s'",
+		   parmnum - 2, IDENTIFIER_POINTER (selector));
+ 	  else
+	    error ("incompatible type for argument %d of `%s'",
+		   parmnum, IDENTIFIER_POINTER (funname));
+	}
+      else
+	error ("incompatible type for argument %d of indirect function call",
+	       parmnum);
+    }
+  else
+    error ("incompatible types in %s", get_spelling (errtype));
+
+  return error_mark_node;
+}
+
+/* Print a warning using MSG.
+   It gets OPNAME as its one parameter.
+   If OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
+   FUNCTION and ARGNUM are handled specially if we are building an
+   Objective-C selector.  */
+
+static void
+warn_for_assignment (msg, opname, function, argnum)
+     char *msg;
+     char *opname;
+     tree function;
+     int argnum;
+{
+  static char argstring[] = "passing arg %d of `%s'";
+  static char argnofun[] =  "passing arg %d";
+
+  if (opname == 0)
+    {
+      tree selector = maybe_building_objc_message_expr ();
+      
+      if (selector && argnum > 2)
+	{
+	  function = selector;
+	  argnum -= 2;
+	}
+      if (function)
+	{
+	  /* Function name is known; supply it.  */
+	  opname = (char *) alloca (IDENTIFIER_LENGTH (function)
+				    + sizeof (argstring) + 25 /*%d*/ + 1);
+	  sprintf (opname, argstring, argnum, IDENTIFIER_POINTER (function));
+	}
+      else
+	{
+	  /* Function name unknown (call through ptr); just give arg number.  */
+	  opname = (char *) alloca (sizeof (argnofun) + 25 /*%d*/ + 1);
+	  sprintf (opname, argnofun, argnum);
+	}
+    }
+  pedwarn (msg, opname);
+}
+
+/* Return nonzero if VALUE is a valid constant-valued expression
+   for use in initializing a static variable; one that can be an
+   element of a "constant" initializer.
+
+   Return null_pointer_node if the value is absolute;
+   if it is relocatable, return the variable that determines the relocation.
+   We assume that VALUE has been folded as much as possible;
+   therefore, we do not need to check for such things as
+   arithmetic-combinations of integers.  */
+
+static tree
+initializer_constant_valid_p (value, endtype)
+     tree value;
+     tree endtype;
+{
+  switch (TREE_CODE (value))
+    {
+    case CONSTRUCTOR:
+      return TREE_STATIC (value) ? null_pointer_node : 0;
+
+    case INTEGER_CST:
+    case REAL_CST:
+    case STRING_CST:
+    case COMPLEX_CST:
+      return null_pointer_node;
+
+    case ADDR_EXPR:
+      return TREE_OPERAND (value, 0);
+
+    case NON_LVALUE_EXPR:
+      return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+
+    case CONVERT_EXPR:
+    case NOP_EXPR:
+      /* Allow conversions between pointer types.  */
+      if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
+	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+      /* Allow conversions between real types.  */
+      if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
+	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+      /* Allow length-preserving conversions between integer types.  */
+      if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
+	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
+	  && tree_int_cst_equal (TYPE_SIZE (TREE_TYPE (value)),
+				 TYPE_SIZE (TREE_TYPE (TREE_OPERAND (value, 0)))))
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
+      /* Allow conversions between integer types only if explicit value.  */
+      if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
+	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
+	{
+	  tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						     endtype);
+	  if (inner == null_pointer_node)
+	    return null_pointer_node;
+	  return 0;
+	}
+      /* Allow (int) &foo provided int is as wide as a pointer.  */
+      if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
+	  && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
+	  && ! tree_int_cst_lt (TYPE_SIZE (TREE_TYPE (value)),
+				TYPE_SIZE (TREE_TYPE (TREE_OPERAND (value, 0)))))
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+					     endtype);
+      /* Allow conversions to union types if the value inside is okay.  */
+      if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
+	return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+					     endtype);
+      return 0;
+
+    case PLUS_EXPR:
+      if (TREE_CODE (endtype) == INTEGER_TYPE
+	  && TYPE_PRECISION (endtype) < POINTER_SIZE)
+	return 0;
+      {
+	tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						    endtype);
+	tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
+						    endtype);
+	/* If either term is absolute, use the other terms relocation.  */
+	if (valid0 == null_pointer_node)
+	  return valid1;
+	if (valid1 == null_pointer_node)
+	  return valid0;
+	return 0;
+      }
+
+    case MINUS_EXPR:
+      if (TREE_CODE (endtype) == INTEGER_TYPE
+	  && TYPE_PRECISION (endtype) < POINTER_SIZE)
+	return 0;
+      {
+	tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+						    endtype);
+	tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
+						    endtype);
+	/* Win if second argument is absolute.  */
+	if (valid1 == null_pointer_node)
+	  return valid0;
+	/* Win if both arguments have the same relocation.
+	   Then the value is absolute.  */
+	if (valid0 == valid1)
+	  return null_pointer_node;
+	return 0;
+      }
+    }
+
+  return 0;
+}
+
+/* Perform appropriate conversions on the initial value of a variable,
+   store it in the declaration DECL,
+   and print any error messages that are appropriate.
+   If the init is invalid, store an ERROR_MARK.  */
+
+void
+store_init_value (decl, init)
+     tree decl, init;
+{
+  register tree value, type;
+
+  /* If variable's type was invalidly declared, just ignore it.  */
+
+  type = TREE_TYPE (decl);
+  if (TREE_CODE (type) == ERROR_MARK)
+    return;
+
+  /* Digest the specified initializer into an expression.  */
+
+  value = digest_init (type, init, NULL_PTR, TREE_STATIC (decl),
+		       TREE_STATIC (decl) || pedantic, 
+		       IDENTIFIER_POINTER (DECL_NAME (decl)));
+
+  /* Store the expression if valid; else report error.  */
+
+#if 0
+  /* Note that this is the only place we can detect the error
+     in a case such as   struct foo bar = (struct foo) { x, y };
+     where there is one initial value which is a constructor expression.  */
+  if (value == error_mark_node)
+    ;
+  else if (TREE_STATIC (decl) && ! TREE_CONSTANT (value))
+    {
+      error ("initializer for static variable is not constant");
+      value = error_mark_node;
+    }
+  else if (TREE_STATIC (decl)
+	   && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
+    {
+      error ("initializer for static variable uses complicated arithmetic");
+      value = error_mark_node;
+    }
+  else
+    {
+      if (pedantic && TREE_CODE (value) == CONSTRUCTOR)
+	{
+	  if (! TREE_CONSTANT (value))
+	    pedwarn ("aggregate initializer is not constant");
+	  else if (! TREE_STATIC (value))
+	    pedwarn ("aggregate initializer uses complicated arithmetic");
+	}
+    }
+#endif
+
+  /* ANSI wants warnings about out-of-range constant initializers.  */
+  constant_expression_warning (value);
+
+  DECL_INITIAL (decl) = value;
+}
+
+/* Methods for storing and printing names for error messages.  */
+
+/* Implement a spelling stack that allows components of a name to be pushed
+   and popped.  Each element on the stack is this structure.  */
+
+struct spelling
+{
+  int kind;
+  union
+    {
+      int i;
+      char *s;
+    } u;
+};
+
+#define SPELLING_STRING 1
+#define SPELLING_MEMBER 2
+#define SPELLING_BOUNDS 3
+
+static struct spelling *spelling;	/* Next stack element (unused).  */
+static struct spelling *spelling_base;	/* Spelling stack base.  */
+static int spelling_size;		/* Size of the spelling stack.  */
+
+/* Macros to save and restore the spelling stack around push_... functions.
+   Alternative to SAVE_SPELLING_STACK.  */
+
+#define SPELLING_DEPTH() (spelling - spelling_base)
+#define RESTORE_SPELLING_DEPTH(depth) (spelling = spelling_base + depth)
+
+/* Save and restore the spelling stack around arbitrary C code.  */
+
+#define SAVE_SPELLING_DEPTH(code)		\
+{						\
+  int __depth = SPELLING_DEPTH ();		\
+  code;						\
+  RESTORE_SPELLING_DEPTH (__depth);		\
+}
+
+/* Push an element on the spelling stack with type KIND and assign VALUE
+   to MEMBER.  */
+
+#define PUSH_SPELLING(KIND, VALUE, MEMBER)				\
+{									\
+  int depth = SPELLING_DEPTH ();					\
+									\
+  if (depth >= spelling_size)						\
+    {									\
+      spelling_size += 10;						\
+      if (spelling_base == 0)						\
+	spelling_base							\
+	  = (struct spelling *) xmalloc (spelling_size * sizeof (struct spelling));	\
+      else								\
+        spelling_base							\
+	  = (struct spelling *) xrealloc (spelling_base,		\
+					  spelling_size * sizeof (struct spelling));	\
+      RESTORE_SPELLING_DEPTH (depth);					\
+    }									\
+									\
+  spelling->kind = (KIND);						\
+  spelling->MEMBER = (VALUE);						\
+  spelling++;								\
+}
+
+/* Push STRING on the stack.  Printed literally.  */
+
+static void
+push_string (string)
+     char *string;
+{
+  PUSH_SPELLING (SPELLING_STRING, string, u.s);
+}
+
+/* Push a member name on the stack.  Printed as '.' STRING.  */
+
+static void
+push_member_name (string)
+     char *string;
+{
+  PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
+}
+
+/* Push an array bounds on the stack.  Printed as [BOUNDS].  */
+
+static void
+push_array_bounds (bounds)
+     int bounds;
+{
+  PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
+}
+
+/* Compute the maximum size in bytes of the printed spelling.  */
+
+static int
+spelling_length ()
+{
+  register int size = 0;
+  register struct spelling *p;
+
+  for (p = spelling_base; p < spelling; p++)
+    {
+      if (p->kind == SPELLING_BOUNDS)
+	size += 25;
+      else
+	size += strlen (p->u.s) + 1;
+    }
+
+  return size;
+}
+
+/* Print the spelling to BUFFER and return it.  */
+
+static char *
+print_spelling (buffer)
+     register char *buffer;
+{
+  register char *d = buffer;
+  register char *s;
+  register struct spelling *p;
+
+  for (p = spelling_base; p < spelling; p++)
+    if (p->kind == SPELLING_BOUNDS)
+      {
+	sprintf (d, "[%d]", p->u.i);
+	d += strlen (d);
+      }
+    else
+      {
+	if (p->kind == SPELLING_MEMBER)
+	  *d++ = '.';
+	for (s = p->u.s; *d = *s++; d++)
+	  ;
+      }
+  *d++ = '\0';
+  return buffer;
+}
+
+/* Provide a means to pass component names derived from the spelling stack.  */
+
+char initialization_message;
+
+/* Interpret the spelling of the given ERRTYPE message.  */
+
+static char *
+get_spelling (errtype)
+     char *errtype;
+{
+  static char *buffer;
+  static int size = -1;
+
+  if (errtype == &initialization_message)
+    {
+      /* Avoid counting chars */
+      static char message[] = "initialization of `%s'";
+      register int needed = sizeof (message) + spelling_length () + 1;
+      char *temp;
+
+      if (size < 0)
+	buffer = (char *) xmalloc (size = needed);
+      if (needed > size)
+	buffer = (char *) xrealloc (buffer, size = needed);
+
+      temp = (char *) alloca (needed);
+      sprintf (buffer, message, print_spelling (temp));
+      return buffer;
+    }
+
+  return errtype;
+}
+
+/* Issue an error message for a bad initializer component.
+   FORMAT describes the message.  OFWHAT is the name for the component.
+   LOCAL is a format string for formatting the insertion of the name
+   into the message.
+
+   If OFWHAT is null, the component name is stored on the spelling stack.
+   If the component name is a null string, then LOCAL is omitted entirely.  */
+
+void
+error_init (format, local, ofwhat)
+     char *format, *local, *ofwhat;
+{
+  char *buffer;
+
+  if (ofwhat == 0)
+    ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
+  buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
+
+  if (*ofwhat)
+    sprintf (buffer, local, ofwhat);
+  else
+    buffer[0] = 0;
+
+  error (format, buffer);
+}
+
+/* Issue a pedantic warning for a bad initializer component.
+   FORMAT describes the message.  OFWHAT is the name for the component.
+   LOCAL is a format string for formatting the insertion of the name
+   into the message.
+
+   If OFWHAT is null, the component name is stored on the spelling stack.
+   If the component name is a null string, then LOCAL is omitted entirely.  */
+
+void
+pedwarn_init (format, local, ofwhat)
+     char *format, *local, *ofwhat;
+{
+  char *buffer;
+
+  if (ofwhat == 0)
+    ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
+  buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
+
+  if (*ofwhat)
+    sprintf (buffer, local, ofwhat);
+  else
+    buffer[0] = 0;
+
+  pedwarn (format, buffer);
+}
+
+/* Keep a pointer to the last free TREE_LIST node as we digest an initializer,
+   so that we can reuse it.  This is set in digest_init, and used in
+   process_init_constructor.
+
+   We will never keep more than one free TREE_LIST node here.  This is for
+   two main reasons.  First, we take elements off the old list and add them
+   to the new list one at a time, thus there should never be more than
+   one free TREE_LIST at a time, and thus even if there is, we will never
+   need more than one.  Secondly, to avoid dangling pointers to freed obstacks,
+   we want to always ensure that we have either a pointer to a valid TREE_LIST
+   within the current initializer, or else a pointer to null.  */
+
+static tree free_tree_list = NULL_TREE;
+
+/* Digest the parser output INIT as an initializer for type TYPE.
+   Return a C expression of type TYPE to represent the initial value.
+
+   If TAIL is nonzero, it points to a variable holding a list of elements
+   of which INIT is the first.  We update the list stored there by
+   removing from the head all the elements that we use.
+   Normally this is only one; we use more than one element only if
+   TYPE is an aggregate and INIT is not a constructor.
+
+   The arguments REQUIRE_CONSTANT and CONSTRUCTOR_CONSTANT request errors
+   if non-constant initializers or elements are seen.  CONSTRUCTOR_CONSTANT
+   applies only to elements of constructors.
+
+   If OFWHAT is nonnull, it specifies what we are initializing, for error
+   messages.   Examples: variable name, variable.member, array[44].
+   If OFWHAT is null, the component name is stored on the spelling stack.
+   (That is true for all nested calls to digest_init.)  */
+
+tree
+digest_init (type, init, tail, require_constant, constructor_constant, ofwhat)
+     tree type, init, *tail;
+     int require_constant, constructor_constant;
+     char *ofwhat;
+{
+  enum tree_code code = TREE_CODE (type);
+  tree element = 0;
+  tree old_tail_contents;
+  /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR
+     tree node which has no TREE_TYPE.  */
+  int raw_constructor
+    = TREE_CODE (init) == CONSTRUCTOR && TREE_TYPE (init) == 0;
+  tree inside_init = init;
+
+  /* Make sure there is just one "partially bracketed" message
+     per top-level initializer or constructor.  */
+  if (ofwhat != 0)
+    partial_bracket_mentioned = 0;
+
+  /* By default, assume we use one element from a list.
+     We correct this later in the cases where it is not true.
+
+     Thus, we update TAIL now to point to the next element, and save the
+     old value in OLD_TAIL_CONTENTS.  If we didn't actually use the first
+     element, then we will reset TAIL before proceeding.  FREE_TREE_LIST
+     is handled similarly.  */
+
+  if (tail)
+    {
+      old_tail_contents = *tail;
+      *tail = TREE_CHAIN (*tail);
+      free_tree_list = old_tail_contents;
+    }
+  else
+    free_tree_list = 0;
+
+  if (init == error_mark_node)
+    return init;
+
+  /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+  /* Do not use STRIP_NOPS here.  We do not want an enumerator
+     whose value is 0 to count as a null pointer constant.  */
+  if (TREE_CODE (init) == NON_LVALUE_EXPR)
+    inside_init = TREE_OPERAND (init, 0);
+
+  if (inside_init && raw_constructor
+      && CONSTRUCTOR_ELTS (inside_init) != 0
+      && TREE_CHAIN (CONSTRUCTOR_ELTS (inside_init)) == 0)
+    {
+      element = TREE_VALUE (CONSTRUCTOR_ELTS (inside_init));
+      /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
+      if (element && TREE_CODE (element) == NON_LVALUE_EXPR)
+	element = TREE_OPERAND (element, 0);
+    }
+
+  /* Initialization of an array of chars from a string constant
+     optionally enclosed in braces.  */
+
+  if (code == ARRAY_TYPE)
+    {
+      tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
+      if ((typ1 == char_type_node
+	   || typ1 == signed_char_type_node
+	   || typ1 == unsigned_char_type_node
+	   || typ1 == unsigned_wchar_type_node
+	   || typ1 == signed_wchar_type_node)
+	  && ((inside_init && TREE_CODE (inside_init) == STRING_CST)
+	      || (element && TREE_CODE (element) == STRING_CST)))
+	{
+	  tree string = element ? element : inside_init;
+
+	  if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
+	       != char_type_node)
+	      && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
+	    {
+	      error_init ("char-array%s initialized from wide string",
+			  " `%s'", ofwhat);
+	      return error_mark_node;
+	    }
+	  if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string)))
+	       == char_type_node)
+	      && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
+	    {
+	      error_init ("int-array%s initialized from non-wide string",
+			  " `%s'", ofwhat);
+	      return error_mark_node;
+	    }
+
+	  TREE_TYPE (string) = type;
+	  if (TYPE_DOMAIN (type) != 0
+	      && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
+	    {
+	      register int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
+	      size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+	      /* Subtract 1 (or sizeof (wchar_t))
+		 because it's ok to ignore the terminating null char
+		 that is counted in the length of the constant.  */
+	      if (size < TREE_STRING_LENGTH (string)
+		  - (TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node)
+		     ? TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT
+		     : 1))
+		pedwarn_init (
+		  "initializer-string for array of chars%s is too long",
+		  " `%s'", ofwhat);
+	    }
+	  return string;
+	}
+    }
+
+  /* Any type except an array can be initialized
+     from an expression of the same type, optionally with braces.
+     For an array, this is allowed only for a string constant.  */
+
+  if (inside_init && TREE_TYPE (inside_init) != 0
+      && ((TYPE_MAIN_VARIANT (TREE_TYPE (inside_init))
+	   == TYPE_MAIN_VARIANT (type))
+	  || (code == ARRAY_TYPE
+	      && comptypes (TREE_TYPE (inside_init), type))
+	  || (code == POINTER_TYPE
+	      && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
+		  || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE)
+	      && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
+			    TREE_TYPE (type)))))
+    {
+      if (code == POINTER_TYPE
+	  && (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
+	      || TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE))
+	inside_init = default_conversion (inside_init);
+      else if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST)
+	{
+	  error_init ("array%s initialized from non-constant array expression",
+		      " `%s'", ofwhat);
+	  return error_mark_node;
+	}
+
+      if (optimize && TREE_READONLY (inside_init)
+	  && TREE_CODE (inside_init) == VAR_DECL)
+	inside_init = decl_constant_value (inside_init);
+
+      if (require_constant && ! TREE_CONSTANT (inside_init))
+	{
+	  error_init ("initializer element%s is not constant",
+		      " for `%s'", ofwhat);
+	  inside_init = error_mark_node;
+	}
+      else if (require_constant
+	       && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
+	{
+	  error_init ("initializer element%s is not computable at load time",
+		      " for `%s'", ofwhat);
+	  inside_init = error_mark_node;
+	}
+
+      return inside_init;
+    }
+
+  if (element && (TREE_TYPE (element) == type
+		  || (code == ARRAY_TYPE && TREE_TYPE (element)
+		      && comptypes (TREE_TYPE (element), type))))
+    {
+      if (code == ARRAY_TYPE)
+	{
+	  error_init ("array%s initialized from non-constant array expression",
+		      " `%s'", ofwhat);
+	  return error_mark_node;
+	}
+      if (pedantic && (code == RECORD_TYPE || code == UNION_TYPE))
+	pedwarn ("single-expression nonscalar initializer has braces");
+      if (optimize && TREE_READONLY (element) && TREE_CODE (element) == VAR_DECL)
+	element = decl_constant_value (element);
+
+      if (require_constant && ! TREE_CONSTANT (element))
+	{
+	  error_init ("initializer element%s is not constant",
+		      " for `%s'", ofwhat);
+	  element = error_mark_node;
+	}
+      else if (require_constant
+	       && initializer_constant_valid_p (element, TREE_TYPE (element)) == 0)
+	{
+	  error_init ("initializer element%s is not computable at load time",
+		      " for `%s'", ofwhat);
+	  element = error_mark_node;
+	}
+
+      return element;
+    }
+
+  /* Check for initializing a union by its first field.
+     Such an initializer must use braces.  */
+
+  if (code == UNION_TYPE)
+    {
+      tree result;
+      tree field = TYPE_FIELDS (type);
+
+      /* Find the first named field.  ANSI decided in September 1990
+	 that only named fields count here.  */
+      while (field && DECL_NAME (field) == 0)
+	field = TREE_CHAIN (field);
+
+      if (field == 0)
+	{
+	  error_init ("union%s with no named members cannot be initialized",
+		      " `%s'", ofwhat);
+	  return error_mark_node;
+	}
+
+      if (raw_constructor)
+	result = process_init_constructor (type, inside_init, NULL_PTR,
+					   require_constant,
+					   constructor_constant, ofwhat);
+      else if (tail != 0)
+	{
+	  *tail = old_tail_contents;
+	  free_tree_list = NULL_TREE;
+	  result = process_init_constructor (type, NULL_TREE, tail,
+					     require_constant,
+					     constructor_constant, ofwhat);
+	}
+      else
+	result = 0;
+
+      if (result)
+	return result;
+    }
+
+  /* Handle scalar types, including conversions.  */
+
+  if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
+      || code == ENUMERAL_TYPE || code == COMPLEX_TYPE)
+    {
+      if (raw_constructor)
+	{
+	  if (element == 0)
+	    {
+	      error_init (
+	 	  "initializer for scalar%s requires one element",
+		  " `%s'", ofwhat);
+	      return error_mark_node;
+	    }
+	  else
+	    {
+	      /* Deal with extra levels of {...}.  */
+	      if (TREE_CODE (element) == CONSTRUCTOR
+		  && TREE_TYPE (element) == 0)
+		{
+		  error_init (
+			      "initializer for scalar%s requires one element",
+			      " `%s'", ofwhat);
+		  return error_mark_node;
+		}
+	      inside_init = element;
+	    }
+	}
+
+#if 0  /* A non-raw constructor is an actual expression.  */
+      if (TREE_CODE (inside_init) == CONSTRUCTOR)
+	{
+	  error_init ("initializer for scalar%s has extra braces",
+		      " `%s'", ofwhat);
+	  return error_mark_node;
+	}
+#endif
+
+      SAVE_SPELLING_DEPTH
+	({
+	  if (ofwhat)
+	    push_string (ofwhat);
+	  if (!raw_constructor)
+	    inside_init = init;
+	  /* Note that convert_for_assignment calls default_conversion
+	     for arrays and functions.  We must not call it in the
+	     case where inside_init is a null pointer constant.  */
+	  inside_init
+	    = convert_for_assignment (type, inside_init, 
+				      &initialization_message,
+				      NULL_TREE, NULL_TREE, 0);
+	});
+
+      if (require_constant && ! TREE_CONSTANT (inside_init))
+	{
+	  error_init ("initializer element%s is not constant",
+		      " for `%s'", ofwhat);
+	  inside_init = error_mark_node;
+	}
+      else if (require_constant
+	       && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
+	{
+	  error_init ("initializer element%s is not computable at load time",
+		      " for `%s'", ofwhat);
+	  inside_init = error_mark_node;
+	}
+
+      return inside_init;
+    }
+
+  /* Come here only for records and arrays.  */
+
+  if (TYPE_SIZE (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
+    {
+      error_init ("variable-sized object%s may not be initialized",
+		  " `%s'", ofwhat);
+      return error_mark_node;
+    }
+
+  if (code == ARRAY_TYPE || code == RECORD_TYPE)
+    {
+      if (raw_constructor)
+	return process_init_constructor (type, inside_init,
+					 NULL_PTR, constructor_constant,
+					 constructor_constant, ofwhat);
+      else if (tail != 0)
+	{
+	  *tail = old_tail_contents;
+	  free_tree_list = NULL_TREE;
+	  return process_init_constructor (type, NULL_TREE, tail,
+					   constructor_constant,
+					   constructor_constant, ofwhat);
+	}
+      else if (flag_traditional)
+	/* Traditionally one can say `char x[100] = 0;'.  */
+	return process_init_constructor (type,
+					 build_nt (CONSTRUCTOR, NULL_TREE,
+						   tree_cons (NULL_TREE,
+							      inside_init,
+							      NULL_TREE)),
+					 NULL_PTR, constructor_constant,
+					 constructor_constant, ofwhat);
+    }
+
+  error_init ("invalid initializer%s", " for `%s'", ofwhat);
+  return error_mark_node;
+}
+
+/* Process a constructor for a variable of type TYPE.
+   The constructor elements may be specified either with INIT or with ELTS,
+   only one of which should be non-null.
+
+   If INIT is specified, it is a CONSTRUCTOR node which is specifically
+   and solely for initializing this datum.
+
+   If ELTS is specified, it is the address of a variable containing
+   a list of expressions.  We take as many elements as we need
+   from the head of the list and update the list.
+
+   In the resulting constructor, TREE_CONSTANT is set if all elts are
+   constant, and TREE_STATIC is set if, in addition, all elts are simple enough
+   constants that the assembler and linker can compute them.
+
+   The argument CONSTANT_VALUE says to print an error if either the
+   value or any element is not a constant.
+
+   The argument CONSTANT_ELEMENT says to print an error if an element
+   of an aggregate is not constant.  It does not apply to a value
+   which is not a constructor.  
+
+   OFWHAT is a character string describing the object being initialized,
+   for error messages.  It might be "variable" or "variable.member"
+   or "variable[17].member[5]".
+
+   If OFWHAT is null, the description string is stored on the spelling
+   stack.  That is always true for recursive calls.  */
+
+static tree
+process_init_constructor (type, init, elts, constant_value, constant_element,
+			  ofwhat)
+     tree type, init, *elts;
+     int constant_value, constant_element;
+     char *ofwhat;
+{
+  register tree tail;
+  /* List of the elements of the result constructor,
+     in reverse order.  */
+  register tree members = NULL;
+  tree result;
+  int allconstant = 1;
+  int allsimple = 1;
+  int erroneous = 0;
+  int depth = SPELLING_DEPTH ();
+
+  if (ofwhat)
+    push_string (ofwhat);
+
+  /* Make TAIL be the list of elements to use for the initialization,
+     no matter how the data was given to us.  */
+
+  if (elts)
+    {
+      if (warn_missing_braces)
+	{
+	  if (! partial_bracket_mentioned)
+	    warning ("aggregate has a partly bracketed initializer");
+	  partial_bracket_mentioned = 1;
+	}
+      tail = *elts;
+    }
+  else
+    tail = CONSTRUCTOR_ELTS (init);
+
+  /* Gobble as many elements as needed, and make a constructor or initial value
+     for each element of this aggregate.  Chain them together in result.
+     If there are too few, use 0 for each scalar ultimate component.  */
+
+  if (TREE_CODE (type) == ARRAY_TYPE)
+    {
+      tree min_index, max_index;
+      /* These are non-zero only within a range initializer.  */
+      tree start_index = 0, end_index = 0;
+      /* Within a range, this is the value for the elts in the range.  */
+      tree range_val = 0;
+      /* Do arithmetic using double integers, but don't use fold/build,
+	 because these allocate a new tree object everytime they are called,
+	 thus resulting in gcc using too much memory for large
+	 initializers.  */
+      union tree_node current_index_node, members_index_node;
+      tree current_index = &current_index_node;
+      tree members_index = &members_index_node;
+      TREE_TYPE (current_index) = integer_type_node;
+      TREE_TYPE (members_index) = integer_type_node;
+
+      /* If we have array bounds, set our bounds from that.  Otherwise,
+	 we have a lower bound of zero and an unknown upper bound.  */
+      if (TYPE_DOMAIN (type))
+	{
+	  min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
+	  max_index = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
+	}
+      else
+	{
+	  min_index = integer_zero_node;
+	  max_index = 0;
+	}
+
+      TREE_INT_CST_LOW (members_index) = TREE_INT_CST_LOW (min_index);
+      TREE_INT_CST_HIGH (members_index) = TREE_INT_CST_HIGH (min_index);
+
+      /* Don't leave the loop based on index if the next item has an explicit
+	 index value that will override it. */
+
+      for (TREE_INT_CST_LOW (current_index) = TREE_INT_CST_LOW (min_index),
+	   TREE_INT_CST_HIGH (current_index) = TREE_INT_CST_HIGH (min_index);
+	   tail != 0 || end_index;
+	   add_double (TREE_INT_CST_LOW (current_index),
+		       TREE_INT_CST_HIGH (current_index), 1, 0,
+		       &TREE_INT_CST_LOW (current_index),
+		       &TREE_INT_CST_HIGH (current_index)))
+	{
+	  register tree next1 = 0;
+
+	  /* Handle the case where we are inside of a range.
+	     current_index increments through the range,
+	     so just keep reusing the same element of TAIL
+	     until the end of the range.  */
+	  if (end_index != 0)
+	    {
+	      next1 = range_val;
+	      if (!tree_int_cst_lt (current_index, end_index))
+		end_index = 0;
+	    }
+
+	  /* If this element specifies an index,
+	     move to that index before storing it in the new list.  */
+	  else if (TREE_PURPOSE (tail) != 0)
+	    {
+	      int win = 0;
+	      tree index = TREE_PURPOSE (tail);
+
+	      if (index && (TREE_CODE (index) == NON_LVALUE_EXPR
+			    || TREE_CODE (index) == NOP_EXPR))
+		index = TREE_OPERAND (index, 0);
+
+	      /* Begin a range.  */
+	      if (TREE_CODE (index) == TREE_LIST)
+		{
+		  start_index = TREE_PURPOSE (index);
+		  end_index = TREE_PURPOSE (TREE_CHAIN (index));
+
+		  /* Expose constants.  It Doesn't matter if we change
+		     the mode.*/
+		  if (end_index
+		      && (TREE_CODE (end_index) == NON_LVALUE_EXPR
+			  || TREE_CODE (end_index) == NOP_EXPR))
+		    end_index = TREE_OPERAND (end_index, 0);
+		  if (start_index
+		      && (TREE_CODE (start_index) == NON_LVALUE_EXPR
+			  || TREE_CODE (start_index) == NOP_EXPR))
+		    start_index = TREE_OPERAND (start_index, 0);
+
+		  constant_expression_warning (start_index);
+		  constant_expression_warning (end_index);
+
+		  if ((TREE_CODE (start_index) == IDENTIFIER_NODE) 
+		      || (TREE_CODE (end_index) == IDENTIFIER_NODE))
+		    error ("field name used as index in array initializer");
+		  else if ((TREE_CODE (start_index) != INTEGER_CST)
+			   || (TREE_CODE (end_index) != INTEGER_CST))
+		    error ("non-constant or non-integer array index in initializer");
+		  else if (tree_int_cst_lt (start_index, min_index)
+			   || (max_index && tree_int_cst_lt (max_index, start_index))
+			   || tree_int_cst_lt (end_index, min_index)
+			   || (max_index && tree_int_cst_lt (max_index, end_index)))
+		    error ("array index out of range in initializer");
+		  else if (tree_int_cst_lt (end_index, start_index))
+		    {
+		      /* If the range is empty, don't initialize any elements,
+			 but do reset current_index for the next initializer
+			 element.  */
+		      warning ("empty array initializer range");
+		      tail = TREE_CHAIN (tail);
+		      TREE_INT_CST_LOW (current_index)
+			= TREE_INT_CST_LOW (end_index);
+		      TREE_INT_CST_HIGH (current_index)
+			= TREE_INT_CST_HIGH (end_index);
+		      continue;
+		    }
+		  else
+		    {
+		      TREE_INT_CST_LOW (current_index)
+			= TREE_INT_CST_LOW (start_index);
+		      TREE_INT_CST_HIGH (current_index)
+			= TREE_INT_CST_HIGH (start_index);
+		      win = 1;
+		      /* See if the first element is also the last.  */
+		      if (!tree_int_cst_lt (current_index, end_index))
+			end_index = 0;
+		    }
+		}
+	      else if (TREE_CODE (index) == IDENTIFIER_NODE)
+		error ("field name used as index in array initializer");
+	      else if (TREE_CODE (index) != INTEGER_CST)
+		error ("non-constant array index in initializer");
+	      else if (tree_int_cst_lt (index, min_index)
+		       || (max_index && tree_int_cst_lt (max_index, index)))
+		error ("array index out of range in initializer");
+	      else
+		{
+		  constant_expression_warning (index);
+		  TREE_INT_CST_LOW (current_index) = TREE_INT_CST_LOW (index);
+		  TREE_INT_CST_HIGH (current_index)
+		    = TREE_INT_CST_HIGH (index);
+		  win = 1;
+		}
+
+	      if (!win)
+		{
+		  /* If there was an error, end the current range.  */
+		  end_index = 0;
+		  TREE_VALUE (tail) = error_mark_node;
+		}
+	    }
+
+	  if (max_index && tree_int_cst_lt (max_index, current_index))
+	    break;  /* Stop if we've indeed run out of elements. */
+
+	  /* Now digest the value specified.  */
+	  if (next1 != 0)
+	    ;
+	  else if (TREE_VALUE (tail) != 0)
+	    {
+	      tree tail1 = tail;
+
+	      /* Build the element of this array, with "[]" notation.  For
+		 error messages, we assume that the index fits within a
+		 host int.  */
+	      SAVE_SPELLING_DEPTH
+		({
+		  push_array_bounds (TREE_INT_CST_LOW (current_index));
+		  next1 = digest_init (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
+				       TREE_VALUE (tail), &tail1,
+				       /* Both of these are the same because
+					  a value here is an elt overall.  */
+				       constant_element, constant_element,
+				       NULL_PTR);
+		});
+
+	      if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
+		abort ();
+	      if (tail == tail1 && TYPE_DOMAIN (type) == 0)
+		{
+		  error_init (
+		    "non-empty initializer for array%s of empty elements",
+		    " `%s'", NULL_PTR);
+		  /* Just ignore what we were supposed to use.  */
+		  tail1 = 0;
+		}
+	      tail = tail1;
+	    }
+	  else
+	    {
+	      next1 = error_mark_node;
+	      tail = TREE_CHAIN (tail);
+	    }
+
+	  if (end_index != 0)
+	    range_val = next1;
+
+	  if (next1 == error_mark_node)
+	    erroneous = 1;
+	  else if (!TREE_CONSTANT (next1))
+	    allconstant = 0;
+	  else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
+	    allsimple = 0;
+
+	  /* Now store NEXT1 in the list, I elements from the *end*.
+	     Make the list longer if necessary.  */
+	  while (! tree_int_cst_lt (current_index, members_index))
+	    {
+	      if (free_tree_list)
+		{
+		  TREE_CHAIN (free_tree_list) = members;
+		  TREE_PURPOSE (free_tree_list) = NULL_TREE;
+		  TREE_VALUE (free_tree_list) = NULL_TREE;
+		  members = free_tree_list;
+		  free_tree_list = NULL_TREE;
+		}
+	      else
+		members = tree_cons (NULL_TREE, NULL_TREE, members);
+	      add_double (TREE_INT_CST_LOW (members_index),
+			  TREE_INT_CST_HIGH (members_index), 1, 0,
+			  &TREE_INT_CST_LOW (members_index),
+			  &TREE_INT_CST_HIGH (members_index));
+	    }
+
+	  {
+	    tree temp;
+	    union tree_node idx_node;
+	    tree idx = &idx_node;
+	    TREE_TYPE (idx) = integer_type_node;
+
+	    temp = members;
+	    for (add_double (TREE_INT_CST_LOW (members_index),
+			     TREE_INT_CST_HIGH (members_index), -1, -1,
+			     &TREE_INT_CST_LOW (idx),
+			     &TREE_INT_CST_HIGH (idx));
+		 tree_int_cst_lt (current_index, idx);
+		 add_double (TREE_INT_CST_LOW (idx),
+			     TREE_INT_CST_HIGH (idx), -1, -1,
+			     &TREE_INT_CST_LOW (idx),
+			     &TREE_INT_CST_HIGH (idx)))
+	      temp = TREE_CHAIN (temp);
+	    TREE_VALUE (temp) = next1;
+	  }
+	}
+    }
+  if (TREE_CODE (type) == RECORD_TYPE)
+    {
+      register tree field;
+      int members_length = 0;
+      int i;
+
+      /* Don't leave the loop based on field just yet; see if next item
+	 overrides the expected field first. */
+
+      for (field = TYPE_FIELDS (type), i = 0; tail;
+	   field = TREE_CHAIN (field), i++)
+	{
+	  register tree next1;
+
+	  /* If this element specifies a field, 
+	     move to that field before storing it in the new list.  */
+	  if (TREE_PURPOSE (tail) != 0)
+	    {
+	      int win = 0;
+
+	      if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
+		error ("index value instead of field name in structure initializer");
+	      else
+		{
+		  tree temp;
+		  int j;
+		  for (temp = TYPE_FIELDS (type), j = 0;
+		       temp;
+		       temp = TREE_CHAIN (temp), j++)
+		    if (DECL_NAME (temp) == TREE_PURPOSE (tail))
+		      break;
+		  if (temp)
+		    field = temp, i = j, win = 1;
+		  else
+		    error ("no field `%s' in structure being initialized",
+			   IDENTIFIER_POINTER (TREE_PURPOSE (tail))); 
+		}
+	      if (!win)
+		TREE_VALUE (tail) = error_mark_node;
+	    }
+
+	  if (field == 0)
+	    break;  /* No more fields to init. */
+
+	  if (! DECL_NAME (field))
+	    {
+	      next1 = integer_zero_node;
+	    }
+	  else if (TREE_VALUE (tail) != 0)
+	    {
+	      tree tail1 = tail;
+
+	      /* Build the name of this member, with a "." for membership.  */
+	      SAVE_SPELLING_DEPTH
+		({
+		  push_member_name (IDENTIFIER_POINTER (DECL_NAME (field)));
+		  next1 = digest_init (TREE_TYPE (field),
+				       TREE_VALUE (tail), &tail1,
+				       constant_element, constant_element,
+				       NULL_PTR);
+		});
+	      if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
+		abort ();
+	      tail = tail1;
+	    }
+	  else
+	    {
+	      next1 = error_mark_node;
+	      tail = TREE_CHAIN (tail);
+	    }
+
+	  if (next1 == error_mark_node)
+	    erroneous = 1;
+	  else if (!TREE_CONSTANT (next1))
+	    allconstant = 0;
+	  else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
+	    allsimple = 0;
+
+	  /* Now store NEXT1 in the list, I elements from the *end*.
+	     Make the list longer if necessary.  */
+	  while (i >= members_length)
+	    {
+	      if (free_tree_list)
+		{
+		  TREE_CHAIN (free_tree_list) = members;
+		  TREE_PURPOSE (free_tree_list) = NULL_TREE;
+		  TREE_VALUE (free_tree_list) = NULL_TREE;
+		  members = free_tree_list;
+		  free_tree_list = NULL_TREE;
+		}
+	      else
+		members = tree_cons (NULL_TREE, NULL_TREE, members);
+	      members_length++;
+	    }
+	  {
+	    tree temp;
+	    int j;
+
+	    temp = members;
+	    for (j = members_length - 1; j > i; j--)
+	      temp = TREE_CHAIN (temp);
+	    TREE_VALUE (temp) = next1;
+	    TREE_PURPOSE (temp) = field;
+	  }
+	}
+    }
+  if (TREE_CODE (type) == UNION_TYPE)
+    {
+      register tree field = TYPE_FIELDS (type);
+      register tree next1;
+
+      /* Find the first named field.  ANSI decided in September 1990
+	 that only named fields count here.  */
+      while (field && DECL_NAME (field) == 0)
+	field = TREE_CHAIN (field);
+
+      /* For a union, get the initializer for 1 fld.  */
+
+      if (tail == 0)
+	{
+	  error ("empty initializer for union");
+	  tail = build_tree_list (0, 0);
+	}
+
+      /* If this element specifies a field, initialize via that field.  */
+      if (TREE_PURPOSE (tail) != 0)
+	{
+	  int win = 0;
+
+	  if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL)
+	    /* Handle the case of a call by build_c_cast.  */
+	    field = TREE_PURPOSE (tail), win = 1;
+	  else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE)
+	    error ("index value instead of field name in union initializer");
+	  else
+	    {
+	      tree temp;
+	      for (temp = TYPE_FIELDS (type);
+		   temp;
+		   temp = TREE_CHAIN (temp))
+		if (DECL_NAME (temp) == TREE_PURPOSE (tail))
+		  break;
+	      if (temp)
+		field = temp, win = 1;
+	      else
+		error ("no field `%s' in union being initialized",
+		       IDENTIFIER_POINTER (TREE_PURPOSE (tail)));
+	    }
+	  if (!win)
+	    TREE_VALUE (tail) = error_mark_node;
+	}
+
+      if (TREE_VALUE (tail) != 0)
+	{
+	  tree tail1 = tail;
+
+	  /* Build the name of this member, with a "." for membership.  */
+	  SAVE_SPELLING_DEPTH
+	    ({
+	      push_member_name (IDENTIFIER_POINTER (DECL_NAME (field)));
+	      next1 = digest_init (TREE_TYPE (field),
+				   TREE_VALUE (tail), &tail1,
+				   constant_value, constant_element, NULL_PTR);
+	    });
+	  if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST)
+	    abort ();
+	  tail = tail1;
+	}
+      else
+	{
+	  next1 = error_mark_node;
+	  tail = TREE_CHAIN (tail);
+	}
+
+      if (next1 == error_mark_node)
+	erroneous = 1;
+      else if (!TREE_CONSTANT (next1))
+	allconstant = 0;
+      else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
+	allsimple = 0; 
+     if (free_tree_list)
+	{
+	  TREE_CHAIN (free_tree_list) = members;
+	  TREE_PURPOSE (free_tree_list) = field;
+	  TREE_VALUE (free_tree_list) = next1;
+	  members = free_tree_list;
+	  free_tree_list = NULL_TREE;
+	}
+      else
+	members = tree_cons (field, next1, members);
+    }
+
+  /* If arguments were specified as a list, just remove the ones we used.  */
+  if (elts)
+    *elts = tail;
+  /* If arguments were specified as a constructor,
+     complain unless we used all the elements of the constructor.  */
+  else if (tail)
+    {
+      if (TREE_CODE (type) == UNION_TYPE)
+	{
+	  pedwarn_init ("excess elements in union initializer%s",
+			" after `%s'", NULL_PTR);
+	}
+      else
+	{
+	  pedwarn_init ("excess elements in aggregate initializer%s",
+			" after `%s'", NULL_PTR);
+	}
+    }
+
+  /* It might be possible to use SAVE_SPELLING_DEPTH, but I suspect that
+     some preprocessor somewhere won't accept that much text as an argument.
+     It's also likely to make debugging difficult.  */
+
+  RESTORE_SPELLING_DEPTH (depth);
+
+  if (erroneous)
+    return error_mark_node;
+
+  if (elts)
+    result = build (CONSTRUCTOR, type, NULL_TREE, nreverse (members));
+  else
+    {
+      result = init;
+      CONSTRUCTOR_ELTS (result) = nreverse (members);
+      TREE_TYPE (result) = type;
+      TREE_CONSTANT (result) = 0;
+      TREE_STATIC (result) = 0;
+    }
+  if (allconstant) TREE_CONSTANT (result) = 1;
+  if (allconstant && allsimple) TREE_STATIC (result) = 1;
+  return result;
+}
+
+/* Expand an ASM statement with operands, handling output operands
+   that are not variables or INDIRECT_REFS by transforming such
+   cases into cases that expand_asm_operands can handle.
+
+   Arguments are same as for expand_asm_operands.  */
+
+void
+c_expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
+     tree string, outputs, inputs, clobbers;
+     int vol;
+     char *filename;
+     int line;
+{
+  int noutputs = list_length (outputs);
+  register int i;
+  /* o[I] is the place that output number I should be written.  */
+  register tree *o = (tree *) alloca (noutputs * sizeof (tree));
+  register tree tail;
+
+  if (TREE_CODE (string) == ADDR_EXPR)
+    string = TREE_OPERAND (string, 0);
+  if (TREE_CODE (string) != STRING_CST)
+    {
+      error ("asm template is not a string constant");
+      return;
+    }
+
+  /* Record the contents of OUTPUTS before it is modified.  */
+  for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
+    o[i] = TREE_VALUE (tail);
+
+  /* Perform default conversions on array and function inputs.  */
+  /* Don't do this for other types--
+     it would screw up operands expected to be in memory.  */
+  for (i = 0, tail = inputs; tail; tail = TREE_CHAIN (tail), i++)
+    if (TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == ARRAY_TYPE
+	|| TREE_CODE (TREE_TYPE (TREE_VALUE (tail))) == FUNCTION_TYPE)
+      TREE_VALUE (tail) = default_conversion (TREE_VALUE (tail));
+
+  /* Generate the ASM_OPERANDS insn;
+     store into the TREE_VALUEs of OUTPUTS some trees for
+     where the values were actually stored.  */
+  expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line);
+
+  /* Copy all the intermediate outputs into the specified outputs.  */
+  for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
+    {
+      if (o[i] != TREE_VALUE (tail))
+	{
+	  expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
+		       0, VOIDmode, 0);
+	  free_temp_slots ();
+	}
+      /* Detect modification of read-only values.
+	 (Otherwise done by build_modify_expr.)  */
+      else
+	{
+	  tree type = TREE_TYPE (o[i]);
+	  if (TYPE_READONLY (type)
+	      || ((TREE_CODE (type) == RECORD_TYPE
+		   || TREE_CODE (type) == UNION_TYPE)
+		  && C_TYPE_FIELDS_READONLY (type)))
+	    readonly_warning (o[i], "modification by `asm'");
+	}
+    }
+
+  /* Those MODIFY_EXPRs could do autoincrements.  */
+  emit_queue ();
+}
+
+/* Expand a C `return' statement.
+   RETVAL is the expression for what to return,
+   or a null pointer for `return;' with no value.  */
+
+void
+c_expand_return (retval)
+     tree retval;
+{
+  tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
+
+  if (TREE_THIS_VOLATILE (current_function_decl))
+    warning ("function declared `volatile' has a `return' statement");
+
+  if (!retval)
+    {
+      current_function_returns_null = 1;
+      if (warn_return_type && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
+	warning ("`return' with no value, in function returning non-void");
+      expand_null_return ();
+    }
+  else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
+    {
+      current_function_returns_null = 1;
+      if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
+	pedwarn ("`return' with a value, in function returning void");
+      expand_return (retval);
+    }
+  else
+    {
+      tree t = convert_for_assignment (valtype, retval, "return",
+				       NULL_TREE, NULL_TREE, 0);
+      tree res = DECL_RESULT (current_function_decl);
+      t = build (MODIFY_EXPR, TREE_TYPE (res),
+		 res, convert (TREE_TYPE (res), t));
+      expand_return (t);
+      current_function_returns_value = 1;
+    }
+}
+
+/* Start a C switch statement, testing expression EXP.
+   Return EXP if it is valid, an error node otherwise.  */
+
+tree
+c_expand_start_case (exp)
+     tree exp;
+{
+  register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
+  tree type = TREE_TYPE (exp);
+
+  if (code != INTEGER_TYPE && code != ENUMERAL_TYPE && code != ERROR_MARK)
+    {
+      error ("switch quantity not an integer");
+      exp = error_mark_node;
+    }
+  else
+    {
+      tree index;
+      type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
+
+      if (warn_traditional
+	  && (type == long_integer_type_node
+	      || type == long_unsigned_type_node))
+	pedwarn ("`long' switch expression not converted to `int' in ANSI C");
+
+      exp = default_conversion (exp);
+      type = TREE_TYPE (exp);
+      index = get_unwidened (exp, NULL_TREE);
+      /* We can't strip a conversion from a signed type to an unsigned,
+	 because if we did, int_fits_type_p would do the wrong thing
+	 when checking case values for being in range,
+	 and it's too hard to do the right thing.  */
+      if (TREE_UNSIGNED (TREE_TYPE (exp))
+	  == TREE_UNSIGNED (TREE_TYPE (index)))
+	exp = index;
+    }
+
+  expand_start_case (1, exp, type, "switch statement");
+
+  return exp;
+}