Return to c-decl.c CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/c-decl.c, revision 1.1

1.1     ! root        1: /* Process declarations and variables for C compiler.
        !             2:    Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GNU CC.
        !             5: 
        !             6: GNU CC is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 2, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GNU CC is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GNU CC; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: 
        !            21: /* Process declarations and symbol lookup for C front end.
        !            22:    Also constructs types; the standard scalar types at initialization,
        !            23:    and structure, union, array and enum types when they are declared.  */
        !            24: 
        !            25: /* ??? not all decl nodes are given the most useful possible
        !            26:    line numbers.  For example, the CONST_DECLs for enum values.  */
        !            27: 
        !            28: #include "config.h"
        !            29: #include "tree.h"
        !            30: #include "flags.h"
        !            31: #include "c-tree.h"
        !            32: #include "c-lex.h"
        !            33: #include <stdio.h>
        !            34: 
        !            35: /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
        !            36: enum decl_context
        !            37: { NORMAL,                      /* Ordinary declaration */
        !            38:   FUNCDEF,                     /* Function definition */
        !            39:   PARM,                                /* Declaration of parm before function body */
        !            40:   FIELD,                       /* Declaration inside struct or union */
        !            41:   BITFIELD,                    /* Likewise but with specified width */
        !            42:   TYPENAME};                   /* Typename (inside cast or sizeof)  */
        !            43: 
        !            44: #ifndef CHAR_TYPE_SIZE
        !            45: #define CHAR_TYPE_SIZE BITS_PER_UNIT
        !            46: #endif
        !            47: 
        !            48: #ifndef SHORT_TYPE_SIZE
        !            49: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
        !            50: #endif
        !            51: 
        !            52: #ifndef INT_TYPE_SIZE
        !            53: #define INT_TYPE_SIZE BITS_PER_WORD
        !            54: #endif
        !            55: 
        !            56: #ifndef LONG_TYPE_SIZE
        !            57: #define LONG_TYPE_SIZE BITS_PER_WORD
        !            58: #endif
        !            59: 
        !            60: #ifndef LONG_LONG_TYPE_SIZE
        !            61: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
        !            62: #endif
        !            63: 
        !            64: #ifndef WCHAR_UNSIGNED
        !            65: #define WCHAR_UNSIGNED 0
        !            66: #endif
        !            67: 
        !            68: #ifndef FLOAT_TYPE_SIZE
        !            69: #define FLOAT_TYPE_SIZE BITS_PER_WORD
        !            70: #endif
        !            71: 
        !            72: #ifndef DOUBLE_TYPE_SIZE
        !            73: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
        !            74: #endif
        !            75: 
        !            76: #ifndef LONG_DOUBLE_TYPE_SIZE
        !            77: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
        !            78: #endif
        !            79: 
        !            80: /* We let tm.h override the types used here, to handle trivial differences
        !            81:    such as the choice of unsigned int or long unsigned int for size_t.
        !            82:    When machines start needing nontrivial differences in the size type,
        !            83:    it would be best to do something here to figure out automatically
        !            84:    from other information what type to use.  */
        !            85: 
        !            86: #ifndef SIZE_TYPE
        !            87: #define SIZE_TYPE "long unsigned int"
        !            88: #endif
        !            89: 
        !            90: #ifndef PTRDIFF_TYPE
        !            91: #define PTRDIFF_TYPE "long int"
        !            92: #endif
        !            93: 
        !            94: #ifndef WCHAR_TYPE
        !            95: #define WCHAR_TYPE "int"
        !            96: #endif
        !            97: 
        !            98: /* a node which has tree code ERROR_MARK, and whose type is itself.
        !            99:    All erroneous expressions are replaced with this node.  All functions
        !           100:    that accept nodes as arguments should avoid generating error messages
        !           101:    if this node is one of the arguments, since it is undesirable to get
        !           102:    multiple error messages from one error in the input.  */
        !           103: 
        !           104: tree error_mark_node;
        !           105: 
        !           106: /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
        !           107: 
        !           108: tree short_integer_type_node;
        !           109: tree integer_type_node;
        !           110: tree long_integer_type_node;
        !           111: tree long_long_integer_type_node;
        !           112: 
        !           113: tree short_unsigned_type_node;
        !           114: tree unsigned_type_node;
        !           115: tree long_unsigned_type_node;
        !           116: tree long_long_unsigned_type_node;
        !           117: 
        !           118: tree ptrdiff_type_node;
        !           119: 
        !           120: tree unsigned_char_type_node;
        !           121: tree signed_char_type_node;
        !           122: tree char_type_node;
        !           123: tree wchar_type_node;
        !           124: tree signed_wchar_type_node;
        !           125: tree unsigned_wchar_type_node;
        !           126: 
        !           127: tree float_type_node;
        !           128: tree double_type_node;
        !           129: tree long_double_type_node;
        !           130: 
        !           131: tree complex_integer_type_node;
        !           132: tree complex_float_type_node;
        !           133: tree complex_double_type_node;
        !           134: tree complex_long_double_type_node;
        !           135: 
        !           136: tree intQI_type_node;
        !           137: tree intHI_type_node;
        !           138: tree intSI_type_node;
        !           139: tree intDI_type_node;
        !           140: 
        !           141: tree unsigned_intQI_type_node;
        !           142: tree unsigned_intHI_type_node;
        !           143: tree unsigned_intSI_type_node;
        !           144: tree unsigned_intDI_type_node;
        !           145: 
        !           146: /* a VOID_TYPE node.  */
        !           147: 
        !           148: tree void_type_node;
        !           149: 
        !           150: /* Nodes for types `void *' and `const void *'.  */
        !           151: 
        !           152: tree ptr_type_node, const_ptr_type_node;
        !           153: 
        !           154: /* Nodes for types `char *' and `const char *'.  */
        !           155: 
        !           156: tree string_type_node, const_string_type_node;
        !           157: 
        !           158: /* Type `char[SOMENUMBER]'.
        !           159:    Used when an array of char is needed and the size is irrelevant.  */
        !           160: 
        !           161: tree char_array_type_node;
        !           162: 
        !           163: /* Type `int[SOMENUMBER]' or something like it.
        !           164:    Used when an array of int needed and the size is irrelevant.  */
        !           165: 
        !           166: tree int_array_type_node;
        !           167: 
        !           168: /* Type `wchar_t[SOMENUMBER]' or something like it.
        !           169:    Used when a wide string literal is created.  */
        !           170: 
        !           171: tree wchar_array_type_node;
        !           172: 
        !           173: /* type `int ()' -- used for implicit declaration of functions.  */
        !           174: 
        !           175: tree default_function_type;
        !           176: 
        !           177: /* function types `double (double)' and `double (double, double)', etc.  */
        !           178: 
        !           179: tree double_ftype_double, double_ftype_double_double;
        !           180: tree int_ftype_int, long_ftype_long;
        !           181: 
        !           182: /* Function type `void (void *, void *, int)' and similar ones */
        !           183: 
        !           184: tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
        !           185: 
        !           186: /* Function type `char *(char *, char *)' and similar ones */
        !           187: tree string_ftype_ptr_ptr, int_ftype_string_string;
        !           188: 
        !           189: /* Function type `int (const void *, const void *, size_t)' */
        !           190: tree int_ftype_cptr_cptr_sizet;
        !           191: 
        !           192: /* Two expressions that are constants with value zero.
        !           193:    The first is of type `int', the second of type `void *'.  */
        !           194: 
        !           195: tree integer_zero_node;
        !           196: tree null_pointer_node;
        !           197: 
        !           198: /* A node for the integer constant 1.  */
        !           199: 
        !           200: tree integer_one_node;
        !           201: 
        !           202: /* Nonzero if we have seen an invalid cross reference
        !           203:    to a struct, union, or enum, but not yet printed the message.  */
        !           204: 
        !           205: tree pending_invalid_xref;
        !           206: /* File and line to appear in the eventual error message.  */
        !           207: char *pending_invalid_xref_file;
        !           208: int pending_invalid_xref_line;
        !           209: 
        !           210: /* While defining an enum type, this is 1 plus the last enumerator
        !           211:    constant value.  Note that will do not have to save this or `enum_overflow'
        !           212:    around nested function definition since such a definition could only
        !           213:    occur in an enum value expression and we don't use these variables in
        !           214:    that case.  */
        !           215: 
        !           216: static tree enum_next_value;
        !           217: 
        !           218: /* Nonzero means that there was overflow computing enum_next_value.  */
        !           219: 
        !           220: static int enum_overflow;
        !           221: 
        !           222: /* Parsing a function declarator leaves a list of parameter names
        !           223:    or a chain or parameter decls here.  */
        !           224: 
        !           225: static tree last_function_parms;
        !           226: 
        !           227: /* Parsing a function declarator leaves here a chain of structure
        !           228:    and enum types declared in the parmlist.  */
        !           229: 
        !           230: static tree last_function_parm_tags;
        !           231: 
        !           232: /* After parsing the declarator that starts a function definition,
        !           233:    `start_function' puts here the list of parameter names or chain of decls.
        !           234:    `store_parm_decls' finds it here.  */
        !           235: 
        !           236: static tree current_function_parms;
        !           237: 
        !           238: /* Similar, for last_function_parm_tags.  */
        !           239: static tree current_function_parm_tags;
        !           240: 
        !           241: /* Similar, for the file and line that the prototype came from if this is
        !           242:    an old-style definition.  */
        !           243: static char *current_function_prototype_file;
        !           244: static int current_function_prototype_line;
        !           245: 
        !           246: /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
        !           247:    that have names.  Here so we can clear out their names' definitions
        !           248:    at the end of the function.  */
        !           249: 
        !           250: static tree named_labels;
        !           251: 
        !           252: /* A list of LABEL_DECLs from outer contexts that are currently shadowed.  */
        !           253: 
        !           254: static tree shadowed_labels;
        !           255: 
        !           256: /* Nonzero when store_parm_decls is called indicates a varargs function.
        !           257:    Value not meaningful after store_parm_decls.  */
        !           258: 
        !           259: static int c_function_varargs;
        !           260: 
        !           261: /* The FUNCTION_DECL for the function currently being compiled,
        !           262:    or 0 if between functions.  */
        !           263: tree current_function_decl;
        !           264: 
        !           265: /* Set to 0 at beginning of a function definition, set to 1 if
        !           266:    a return statement that specifies a return value is seen.  */
        !           267: 
        !           268: int current_function_returns_value;
        !           269: 
        !           270: /* Set to 0 at beginning of a function definition, set to 1 if
        !           271:    a return statement with no argument is seen.  */
        !           272: 
        !           273: int current_function_returns_null;
        !           274: 
        !           275: /* Set to nonzero by `grokdeclarator' for a function
        !           276:    whose return type is defaulted, if warnings for this are desired.  */
        !           277: 
        !           278: static int warn_about_return_type;
        !           279: 
        !           280: /* Nonzero when starting a function declared `extern inline'.  */
        !           281: 
        !           282: static int current_extern_inline;
        !           283: 
        !           284: /* For each binding contour we allocate a binding_level structure
        !           285:  * which records the names defined in that contour.
        !           286:  * Contours include:
        !           287:  *  0) the global one
        !           288:  *  1) one for each function definition,
        !           289:  *     where internal declarations of the parameters appear.
        !           290:  *  2) one for each compound statement,
        !           291:  *     to record its declarations.
        !           292:  *
        !           293:  * The current meaning of a name can be found by searching the levels from
        !           294:  * the current one out to the global one.
        !           295:  */
        !           296: 
        !           297: /* Note that the information in the `names' component of the global contour
        !           298:    is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers.  */
        !           299: 
        !           300: struct binding_level
        !           301:   {
        !           302:     /* A chain of _DECL nodes for all variables, constants, functions,
        !           303:        and typedef types.  These are in the reverse of the order supplied.
        !           304:      */
        !           305:     tree names;
        !           306: 
        !           307:     /* A list of structure, union and enum definitions,
        !           308:      * for looking up tag names.
        !           309:      * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
        !           310:      * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
        !           311:      * or ENUMERAL_TYPE node.
        !           312:      */
        !           313:     tree tags;
        !           314: 
        !           315:     /* For each level, a list of shadowed outer-level local definitions
        !           316:        to be restored when this level is popped.
        !           317:        Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
        !           318:        whose TREE_VALUE is its old definition (a kind of ..._DECL node).  */
        !           319:     tree shadowed;
        !           320: 
        !           321:     /* For each level (except not the global one),
        !           322:        a chain of BLOCK nodes for all the levels
        !           323:        that were entered and exited one level down.  */
        !           324:     tree blocks;
        !           325: 
        !           326:     /* The BLOCK node for this level, if one has been preallocated.
        !           327:        If 0, the BLOCK is allocated (if needed) when the level is popped.  */
        !           328:     tree this_block;
        !           329: 
        !           330:     /* The binding level which this one is contained in (inherits from).  */
        !           331:     struct binding_level *level_chain;
        !           332: 
        !           333:     /* Nonzero for the level that holds the parameters of a function.  */
        !           334:     char parm_flag;
        !           335: 
        !           336:     /* Nonzero if this level "doesn't exist" for tags.  */
        !           337:     char tag_transparent;
        !           338: 
        !           339:     /* Nonzero if sublevels of this level "don't exist" for tags.
        !           340:        This is set in the parm level of a function definition
        !           341:        while reading the function body, so that the outermost block
        !           342:        of the function body will be tag-transparent.  */
        !           343:     char subblocks_tag_transparent;
        !           344: 
        !           345:     /* Nonzero means make a BLOCK for this level regardless of all else.  */
        !           346:     char keep;
        !           347: 
        !           348:     /* Nonzero means make a BLOCK if this level has any subblocks.  */
        !           349:     char keep_if_subblocks;
        !           350: 
        !           351:     /* Number of decls in `names' that have incomplete 
        !           352:        structure or union types.  */
        !           353:     int n_incomplete;
        !           354: 
        !           355:     /* A list of decls giving the (reversed) specified order of parms,
        !           356:        not including any forward-decls in the parmlist.
        !           357:        This is so we can put the parms in proper order for assign_parms.  */
        !           358:     tree parm_order;
        !           359:   };
        !           360: 
        !           361: #define NULL_BINDING_LEVEL (struct binding_level *) NULL
        !           362:   
        !           363: /* The binding level currently in effect.  */
        !           364: 
        !           365: static struct binding_level *current_binding_level;
        !           366: 
        !           367: /* A chain of binding_level structures awaiting reuse.  */
        !           368: 
        !           369: static struct binding_level *free_binding_level;
        !           370: 
        !           371: /* The outermost binding level, for names of file scope.
        !           372:    This is created when the compiler is started and exists
        !           373:    through the entire run.  */
        !           374: 
        !           375: static struct binding_level *global_binding_level;
        !           376: 
        !           377: /* Binding level structures are initialized by copying this one.  */
        !           378: 
        !           379: static struct binding_level clear_binding_level
        !           380:   = {NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0};
        !           381: 
        !           382: /* Nonzero means unconditionally make a BLOCK for the next level pushed.  */
        !           383: 
        !           384: static int keep_next_level_flag;
        !           385: 
        !           386: /* Nonzero means make a BLOCK for the next level pushed
        !           387:    if it has subblocks.  */
        !           388: 
        !           389: static int keep_next_if_subblocks;
        !           390:   
        !           391: /* The chain of outer levels of label scopes.
        !           392:    This uses the same data structure used for binding levels,
        !           393:    but it works differently: each link in the chain records
        !           394:    saved values of named_labels and shadowed_labels for
        !           395:    a label binding level outside the current one.  */
        !           396: 
        !           397: static struct binding_level *label_level_chain;
        !           398: 
        !           399: /* Forward declarations.  */
        !           400: 
        !           401: static tree grokparms (), grokdeclarator ();
        !           402: tree pushdecl ();
        !           403: tree builtin_function ();
        !           404: void shadow_tag_warned ();
        !           405: 
        !           406: static tree lookup_tag ();
        !           407: static tree lookup_tag_reverse ();
        !           408: tree lookup_name_current_level ();
        !           409: static char *redeclaration_error_message ();
        !           410: static void layout_array_type ();
        !           411: 
        !           412: /* C-specific option variables.  */
        !           413: 
        !           414: /* Nonzero means allow type mismatches in conditional expressions;
        !           415:    just make their values `void'.   */
        !           416: 
        !           417: int flag_cond_mismatch;
        !           418: 
        !           419: /* Nonzero means give `double' the same size as `float'.  */
        !           420: 
        !           421: int flag_short_double;
        !           422: 
        !           423: /* Nonzero means don't recognize the keyword `asm'.  */
        !           424: 
        !           425: int flag_no_asm;
        !           426: 
        !           427: /* Nonzero means don't recognize any builtin functions.  */
        !           428: 
        !           429: int flag_no_builtin;
        !           430: 
        !           431: /* Nonzero means don't recognize the non-ANSI builtin functions.
        !           432:    -ansi sets this.  */
        !           433: 
        !           434: int flag_no_nonansi_builtin;
        !           435: 
        !           436: /* Nonzero means do some things the same way PCC does.  */
        !           437: 
        !           438: int flag_traditional;
        !           439: 
        !           440: /* Nonzero means to allow single precision math even if we're generally
        !           441:    being traditional. */
        !           442: int flag_allow_single_precision = 0;
        !           443: 
        !           444: /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
        !           445: 
        !           446: int flag_signed_bitfields = 1;
        !           447: int explicit_flag_signed_bitfields = 0;
        !           448: 
        !           449: /* Nonzero means handle `#ident' directives.  0 means ignore them.  */
        !           450: 
        !           451: int flag_no_ident = 0;
        !           452: 
        !           453: /* Nonzero means warn about implicit declarations.  */
        !           454: 
        !           455: int warn_implicit;
        !           456: 
        !           457: /* Nonzero means give string constants the type `const char *'
        !           458:    to get extra warnings from them.  These warnings will be too numerous
        !           459:    to be useful, except in thoroughly ANSIfied programs.  */
        !           460: 
        !           461: int warn_write_strings;
        !           462: 
        !           463: /* Nonzero means warn about pointer casts that can drop a type qualifier
        !           464:    from the pointer target type.  */
        !           465: 
        !           466: int warn_cast_qual;
        !           467: 
        !           468: /* Warn about traditional constructs whose meanings changed in ANSI C.  */
        !           469: 
        !           470: int warn_traditional;
        !           471: 
        !           472: /* Nonzero means warn about sizeof(function) or addition/subtraction
        !           473:    of function pointers.  */
        !           474: 
        !           475: int warn_pointer_arith;
        !           476: 
        !           477: /* Nonzero means warn for non-prototype function decls
        !           478:    or non-prototyped defs without previous prototype.  */
        !           479: 
        !           480: int warn_strict_prototypes;
        !           481: 
        !           482: /* Nonzero means warn for any global function def
        !           483:    without separate previous prototype decl.  */
        !           484: 
        !           485: int warn_missing_prototypes;
        !           486: 
        !           487: /* Nonzero means warn about multiple (redundant) decls for the same single
        !           488:    variable or function.  */
        !           489: 
        !           490: int warn_redundant_decls = 0;
        !           491: 
        !           492: /* Nonzero means warn about extern declarations of objects not at
        !           493:    file-scope level and about *all* declarations of functions (whether
        !           494:    extern or static) not at file-scope level.  Note that we exclude
        !           495:    implicit function declarations.  To get warnings about those, use
        !           496:    -Wimplicit.  */
        !           497: 
        !           498: int warn_nested_externs = 0;
        !           499: 
        !           500: /* Warn about *printf or *scanf format/argument anomalies. */
        !           501: 
        !           502: int warn_format;
        !           503: 
        !           504: /* Warn about a subscript that has type char.  */
        !           505: 
        !           506: int warn_char_subscripts = 0;
        !           507: 
        !           508: /* Warn if a type conversion is done that might have confusing results.  */
        !           509: 
        !           510: int warn_conversion;
        !           511: 
        !           512: /* Warn if adding () is suggested.  */
        !           513: 
        !           514: int warn_parentheses;
        !           515: 
        !           516: /* Warn if initializer is not completely bracketed.  */
        !           517: 
        !           518: int warn_missing_braces;
        !           519: 
        !           520: /* Nonzero means `$' can be in an identifier.
        !           521:    See cccp.c for reasons why this breaks some obscure ANSI C programs.  */
        !           522: 
        !           523: #ifndef DOLLARS_IN_IDENTIFIERS
        !           524: #define DOLLARS_IN_IDENTIFIERS 1
        !           525: #endif
        !           526: int dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
        !           527: 
        !           528: #ifdef NeXT
        !           529: #ifdef HPPA
        !           530: extern void add_vararg_func(char *, char);
        !           531: #endif
        !           532: #endif
        !           533: 
        !           534: /* Decode the string P as a language-specific option for C.
        !           535:    Return 1 if it is recognized (and handle it);
        !           536:    return 0 if not recognized.  */
        !           537:    
        !           538: int
        !           539: c_decode_option (p)
        !           540:      char *p;
        !           541: {
        !           542:   if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
        !           543:     {
        !           544:       flag_traditional = 1;
        !           545:       flag_writable_strings = 1;
        !           546: #if DOLLARS_IN_IDENTIFIERS > 0
        !           547:       dollars_in_ident = 1;
        !           548: #endif
        !           549:     }
        !           550:   else if (!strcmp (p, "-fallow-single-precision"))
        !           551:     flag_allow_single_precision = 1;
        !           552:   else if (!strcmp (p, "-fnotraditional") || !strcmp (p, "-fno-traditional"))
        !           553:     {
        !           554:       flag_traditional = 0;
        !           555:       flag_writable_strings = 0;
        !           556:       dollars_in_ident = DOLLARS_IN_IDENTIFIERS > 1;
        !           557:     }
        !           558:   else if (!strcmp (p, "-fdollars-in-identifiers"))
        !           559:     {
        !           560: #if DOLLARS_IN_IDENTIFIERS > 0
        !           561:       dollars_in_ident = 1;
        !           562: #endif
        !           563:     }
        !           564:   else if (!strcmp (p, "-fnodollars-in-identifiers"))
        !           565:     dollars_in_ident = 0;
        !           566:   else if (!strcmp (p, "-fsigned-char"))
        !           567:     flag_signed_char = 1;
        !           568:   else if (!strcmp (p, "-funsigned-char"))
        !           569:     flag_signed_char = 0;
        !           570:   else if (!strcmp (p, "-fno-signed-char"))
        !           571:     flag_signed_char = 0;
        !           572:   else if (!strcmp (p, "-fno-unsigned-char"))
        !           573:     flag_signed_char = 1;
        !           574:   else if (!strcmp (p, "-fsigned-bitfields")
        !           575:           || !strcmp (p, "-fno-unsigned-bitfields"))
        !           576:     {
        !           577:       flag_signed_bitfields = 1;
        !           578:       explicit_flag_signed_bitfields = 1;
        !           579:     }
        !           580:   else if (!strcmp (p, "-funsigned-bitfields")
        !           581:           || !strcmp (p, "-fno-signed-bitfields"))
        !           582:     {
        !           583:       flag_signed_bitfields = 0;
        !           584:       explicit_flag_signed_bitfields = 1;
        !           585:     }
        !           586:   else if (!strcmp (p, "-fshort-enums"))
        !           587:     flag_short_enums = 1;
        !           588:   else if (!strcmp (p, "-fno-short-enums"))
        !           589:     flag_short_enums = 0;
        !           590:   else if (!strcmp (p, "-fcond-mismatch"))
        !           591:     flag_cond_mismatch = 1;
        !           592:   else if (!strcmp (p, "-fno-cond-mismatch"))
        !           593:     flag_cond_mismatch = 0;
        !           594:   else if (!strcmp (p, "-fshort-double"))
        !           595:     flag_short_double = 1;
        !           596:   else if (!strcmp (p, "-fno-short-double"))
        !           597:     flag_short_double = 0;
        !           598:   else if (!strcmp (p, "-fasm"))
        !           599:     flag_no_asm = 0;
        !           600:   else if (!strcmp (p, "-fno-asm"))
        !           601:     flag_no_asm = 1;
        !           602:   else if (!strcmp (p, "-fbuiltin"))
        !           603:     flag_no_builtin = 0;
        !           604:   else if (!strcmp (p, "-fno-builtin"))
        !           605:     flag_no_builtin = 1;
        !           606:   else if (!strcmp (p, "-fno-ident"))
        !           607:     flag_no_ident = 1;
        !           608:   else if (!strcmp (p, "-fident"))
        !           609:     flag_no_ident = 0;
        !           610:   else if (!strcmp (p, "-ansi"))
        !           611:     flag_no_asm = 1, flag_no_nonansi_builtin = 1, dollars_in_ident = 0;
        !           612:   else if (!strcmp (p, "-Wimplicit"))
        !           613:     warn_implicit = 1;
        !           614:   else if (!strcmp (p, "-Wno-implicit"))
        !           615:     warn_implicit = 0;
        !           616:   else if (!strcmp (p, "-Wwrite-strings"))
        !           617:     warn_write_strings = 1;
        !           618:   else if (!strcmp (p, "-Wno-write-strings"))
        !           619:     warn_write_strings = 0;
        !           620:   else if (!strcmp (p, "-Wcast-qual"))
        !           621:     warn_cast_qual = 1;
        !           622:   else if (!strcmp (p, "-Wno-cast-qual"))
        !           623:     warn_cast_qual = 0;
        !           624:   else if (!strcmp (p, "-Wpointer-arith"))
        !           625:     warn_pointer_arith = 1;
        !           626:   else if (!strcmp (p, "-Wno-pointer-arith"))
        !           627:     warn_pointer_arith = 0;
        !           628:   else if (!strcmp (p, "-Wstrict-prototypes"))
        !           629:     warn_strict_prototypes = 1;
        !           630:   else if (!strcmp (p, "-Wno-strict-prototypes"))
        !           631:     warn_strict_prototypes = 0;
        !           632:   else if (!strcmp (p, "-Wmissing-prototypes"))
        !           633:     warn_missing_prototypes = 1;
        !           634:   else if (!strcmp (p, "-Wno-missing-prototypes"))
        !           635:     warn_missing_prototypes = 0;
        !           636:   else if (!strcmp (p, "-Wredundant-decls"))
        !           637:     warn_redundant_decls = 1;
        !           638:   else if (!strcmp (p, "-Wno-redundant-decls"))
        !           639:     warn_redundant_decls = 0;
        !           640:   else if (!strcmp (p, "-Wnested-externs"))
        !           641:     warn_nested_externs = 1;
        !           642:   else if (!strcmp (p, "-Wno-nested-externs"))
        !           643:     warn_nested_externs = 0;
        !           644:   else if (!strcmp (p, "-Wtraditional"))
        !           645:     warn_traditional = 1;
        !           646:   else if (!strcmp (p, "-Wno-traditional"))
        !           647:     warn_traditional = 0;
        !           648:   else if (!strcmp (p, "-Wformat"))
        !           649:     warn_format = 1;
        !           650:   else if (!strcmp (p, "-Wno-format"))
        !           651:     warn_format = 0;
        !           652: #ifdef NEXT_SEMANTICS
        !           653:   else if (!strcmp (p, "-Wnoformat"))
        !           654:     warn_format = 0;
        !           655: #endif
        !           656:   else if (!strcmp (p, "-Wchar-subscripts"))
        !           657:     warn_char_subscripts = 1;
        !           658:   else if (!strcmp (p, "-Wno-char-subscripts"))
        !           659:     warn_char_subscripts = 0;
        !           660:   else if (!strcmp (p, "-Wconversion"))
        !           661:     warn_conversion = 1;
        !           662:   else if (!strcmp (p, "-Wno-conversion"))
        !           663:     warn_conversion = 0;
        !           664:   else if (!strcmp (p, "-Wparentheses"))
        !           665:     warn_parentheses = 1;
        !           666:   else if (!strcmp (p, "-Wno-parentheses"))
        !           667:     warn_parentheses = 0;
        !           668:   else if (!strcmp (p, "-Wreturn-type"))
        !           669:     warn_return_type = 1;
        !           670:   else if (!strcmp (p, "-Wno-return-type"))
        !           671:     warn_return_type = 0;
        !           672:   else if (!strcmp (p, "-Wcomment"))
        !           673:     ; /* cpp handles this one.  */
        !           674:   else if (!strcmp (p, "-Wno-comment"))
        !           675:     ; /* cpp handles this one.  */
        !           676:   else if (!strcmp (p, "-Wcomments"))
        !           677:     ; /* cpp handles this one.  */
        !           678:   else if (!strcmp (p, "-Wno-comments"))
        !           679:     ; /* cpp handles this one.  */
        !           680:   else if (!strcmp (p, "-Wtrigraphs"))
        !           681:     ; /* cpp handles this one.  */
        !           682:   else if (!strcmp (p, "-Wno-trigraphs"))
        !           683:     ; /* cpp handles this one.  */
        !           684:   else if (!strcmp (p, "-Wimport"))
        !           685:     ; /* cpp handles this one.  */
        !           686:   else if (!strcmp (p, "-Wno-import"))
        !           687:     ; /* cpp handles this one.  */
        !           688:   else if (!strcmp (p, "-Wmissing-braces"))
        !           689:     warn_missing_braces = 1;
        !           690:   else if (!strcmp (p, "-Wno-missing-braces"))
        !           691:     warn_missing_braces = 0;
        !           692:   else if (!strcmp (p, "-Wall"))
        !           693:     {
        !           694:       extra_warnings = 1;
        !           695:       /* We save the value of warn_uninitialized, since if they put
        !           696:         -Wuninitialized on the command line, we need to generate a
        !           697:         warning about not using it without also specifying -O.  */
        !           698:       if (warn_uninitialized != 1)
        !           699:        warn_uninitialized = 2;
        !           700:       warn_implicit = 1;
        !           701:       warn_return_type = 1;
        !           702:       warn_unused = 1;
        !           703:       warn_switch = 1;
        !           704:       warn_format = 1;
        !           705:       warn_char_subscripts = 1;
        !           706: #ifndef NEXT_SEMANTICS
        !           707:       warn_parentheses = 1;
        !           708: #endif
        !           709:       warn_missing_braces = 1;
        !           710:     }
        !           711:   else
        !           712: #ifdef NEXT_SEMANTICS
        !           713:     if (! strcmp (p, "-Wstyle"))
        !           714:     {
        !           715:       warn_parentheses = 1;
        !           716:     }
        !           717:   else
        !           718: #endif
        !           719:     return 0;
        !           720: 
        !           721:   return 1;
        !           722: }
        !           723: 
        !           724: /* Hooks for print_node.  */
        !           725: 
        !           726: void
        !           727: print_lang_decl (file, node, indent)
        !           728:      FILE *file;
        !           729:      tree node;
        !           730:      int indent;
        !           731: {
        !           732: }
        !           733: 
        !           734: void
        !           735: print_lang_type (file, node, indent)
        !           736:      FILE *file;
        !           737:      tree node;
        !           738:      int indent;
        !           739: {
        !           740: }
        !           741: 
        !           742: void
        !           743: print_lang_identifier (file, node, indent)
        !           744:      FILE *file;
        !           745:      tree node;
        !           746:      int indent;
        !           747: {
        !           748:   print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
        !           749:   print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
        !           750:   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
        !           751:   print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
        !           752:   print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
        !           753:   print_node (file, "limbo value", IDENTIFIER_LIMBO_VALUE (node), indent + 4);
        !           754: }
        !           755: 
        !           756: /* Hook called at end of compilation to assume 1 elt
        !           757:    for a top-level array decl that wasn't complete before.  */
        !           758:    
        !           759: void
        !           760: finish_incomplete_decl (decl)
        !           761:      tree decl;
        !           762: {
        !           763:   if (TREE_CODE (decl) == VAR_DECL && TREE_TYPE (decl) != error_mark_node)
        !           764:     {
        !           765:       tree type = TREE_TYPE (decl);
        !           766:       if (TREE_CODE (type) == ARRAY_TYPE
        !           767:          && TYPE_DOMAIN (type) == 0
        !           768:          && TREE_CODE (decl) != TYPE_DECL)
        !           769:        {
        !           770:          complete_array_type (type, NULL_TREE, 1);
        !           771: 
        !           772:          layout_decl (decl, 0);
        !           773:        }
        !           774:     }
        !           775: }
        !           776: 
        !           777: /* Create a new `struct binding_level'.  */
        !           778: 
        !           779: static
        !           780: struct binding_level *
        !           781: make_binding_level ()
        !           782: {
        !           783:   /* NOSTRICT */
        !           784:   return (struct binding_level *) xmalloc (sizeof (struct binding_level));
        !           785: }
        !           786: 
        !           787: /* Nonzero if we are currently in the global binding level.  */
        !           788: 
        !           789: int
        !           790: global_bindings_p ()
        !           791: {
        !           792:   return current_binding_level == global_binding_level;
        !           793: }
        !           794: 
        !           795: void
        !           796: keep_next_level ()
        !           797: {
        !           798:   keep_next_level_flag = 1;
        !           799: }
        !           800: 
        !           801: /* Nonzero if the current level needs to have a BLOCK made.  */
        !           802: 
        !           803: int
        !           804: kept_level_p ()
        !           805: {
        !           806:   return ((current_binding_level->keep_if_subblocks
        !           807:           && current_binding_level->blocks != 0)
        !           808:          || current_binding_level->keep
        !           809:          || current_binding_level->names != 0
        !           810:          || (current_binding_level->tags != 0
        !           811:              && !current_binding_level->tag_transparent));
        !           812: }
        !           813: 
        !           814: /* Identify this binding level as a level of parameters.
        !           815:    DEFINITION_FLAG is 1 for a definition, 0 for a declaration.
        !           816:    But it turns out there is no way to pass the right value for
        !           817:    DEFINITION_FLAG, so we ignore it.  */
        !           818: 
        !           819: void
        !           820: declare_parm_level (definition_flag)
        !           821:      int definition_flag;
        !           822: {
        !           823:   current_binding_level->parm_flag = 1;
        !           824: }
        !           825: 
        !           826: /* Nonzero if currently making parm declarations.  */
        !           827: 
        !           828: int
        !           829: in_parm_level_p ()
        !           830: {
        !           831:   return current_binding_level->parm_flag;
        !           832: }
        !           833: 
        !           834: /* Enter a new binding level.
        !           835:    If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
        !           836:    not for that of tags.  */
        !           837: 
        !           838: void
        !           839: pushlevel (tag_transparent)
        !           840:      int tag_transparent;
        !           841: {
        !           842:   register struct binding_level *newlevel = NULL_BINDING_LEVEL;
        !           843: 
        !           844:   /* If this is the top level of a function,
        !           845:      just make sure that NAMED_LABELS is 0.  */
        !           846: 
        !           847:   if (current_binding_level == global_binding_level)
        !           848:     {
        !           849:       named_labels = 0;
        !           850:     }
        !           851: 
        !           852:   /* Reuse or create a struct for this binding level.  */
        !           853: 
        !           854:   if (free_binding_level)
        !           855:     {
        !           856:       newlevel = free_binding_level;
        !           857:       free_binding_level = free_binding_level->level_chain;
        !           858:     }
        !           859:   else
        !           860:     {
        !           861:       newlevel = make_binding_level ();
        !           862:     }
        !           863: 
        !           864:   /* Add this level to the front of the chain (stack) of levels that
        !           865:      are active.  */
        !           866: 
        !           867:   *newlevel = clear_binding_level;
        !           868:   newlevel->tag_transparent
        !           869:     = (tag_transparent
        !           870:        || (current_binding_level
        !           871:           ? current_binding_level->subblocks_tag_transparent
        !           872:           : 0));
        !           873:   newlevel->level_chain = current_binding_level;
        !           874:   current_binding_level = newlevel;
        !           875:   newlevel->keep = keep_next_level_flag;
        !           876:   keep_next_level_flag = 0;
        !           877:   newlevel->keep_if_subblocks = keep_next_if_subblocks;
        !           878:   keep_next_if_subblocks = 0;
        !           879: }
        !           880: 
        !           881: /* Exit a binding level.
        !           882:    Pop the level off, and restore the state of the identifier-decl mappings
        !           883:    that were in effect when this level was entered.
        !           884: 
        !           885:    If KEEP is nonzero, this level had explicit declarations, so
        !           886:    and create a "block" (a BLOCK node) for the level
        !           887:    to record its declarations and subblocks for symbol table output.
        !           888: 
        !           889:    If FUNCTIONBODY is nonzero, this level is the body of a function,
        !           890:    so create a block as if KEEP were set and also clear out all
        !           891:    label names.
        !           892: 
        !           893:    If REVERSE is nonzero, reverse the order of decls before putting
        !           894:    them into the BLOCK.  */
        !           895: 
        !           896: tree
        !           897: poplevel (keep, reverse, functionbody)
        !           898:      int keep;
        !           899:      int reverse;
        !           900:      int functionbody;
        !           901: {
        !           902:   register tree link;
        !           903:   /* The chain of decls was accumulated in reverse order.
        !           904:      Put it into forward order, just for cleanliness.  */
        !           905:   tree decls;
        !           906:   tree tags = current_binding_level->tags;
        !           907:   tree subblocks = current_binding_level->blocks;
        !           908:   tree block = 0;
        !           909:   tree decl;
        !           910:   int block_previously_created;
        !           911: 
        !           912:   keep |= current_binding_level->keep;
        !           913: 
        !           914:   /* This warning is turned off because it causes warnings for
        !           915:      declarations like `extern struct foo *x'.  */
        !           916: #if 0
        !           917:   /* Warn about incomplete structure types in this level.  */
        !           918:   for (link = tags; link; link = TREE_CHAIN (link))
        !           919:     if (TYPE_SIZE (TREE_VALUE (link)) == 0)
        !           920:       {
        !           921:        tree type = TREE_VALUE (link);
        !           922:        char *errmsg;
        !           923:        switch (TREE_CODE (type))
        !           924:          {
        !           925:          case RECORD_TYPE:
        !           926:            errmsg = "`struct %s' incomplete in scope ending here";
        !           927:            break;
        !           928:          case UNION_TYPE:
        !           929:            errmsg = "`union %s' incomplete in scope ending here";
        !           930:            break;
        !           931:          case ENUMERAL_TYPE:
        !           932:            errmsg = "`enum %s' incomplete in scope ending here";
        !           933:            break;
        !           934:          }
        !           935:        if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
        !           936:          error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
        !           937:        else
        !           938:          /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
        !           939:          error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
        !           940:       }
        !           941: #endif /* 0 */
        !           942: 
        !           943:   /* Get the decls in the order they were written.
        !           944:      Usually current_binding_level->names is in reverse order.
        !           945:      But parameter decls were previously put in forward order.  */
        !           946: 
        !           947:   if (reverse)
        !           948:     current_binding_level->names
        !           949:       = decls = nreverse (current_binding_level->names);
        !           950:   else
        !           951:     decls = current_binding_level->names;
        !           952: 
        !           953:   /* Output any nested inline functions within this block
        !           954:      if they weren't already output.  */
        !           955: 
        !           956:   for (decl = decls; decl; decl = TREE_CHAIN (decl))
        !           957:     if (TREE_CODE (decl) == FUNCTION_DECL
        !           958:        && ! TREE_ASM_WRITTEN (decl)
        !           959:        && DECL_INITIAL (decl) != 0
        !           960:        && TREE_ADDRESSABLE (decl))
        !           961:       {
        !           962:        /* If this decl was copied from a file-scope decl
        !           963:           on account of a block-scope extern decl,
        !           964:           propagate TREE_ADDRESSABLE to the file-scope decl.  */
        !           965:        if (DECL_ABSTRACT_ORIGIN (decl) != 0)
        !           966:          TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
        !           967:        else
        !           968:          {
        !           969:            push_function_context ();
        !           970:            output_inline_function (decl);
        !           971:            pop_function_context ();
        !           972:          }
        !           973:       }
        !           974: 
        !           975:   /* If there were any declarations or structure tags in that level,
        !           976:      or if this level is a function body,
        !           977:      create a BLOCK to record them for the life of this function.  */
        !           978: 
        !           979:   block = 0;
        !           980:   block_previously_created = (current_binding_level->this_block != 0);
        !           981:   if (block_previously_created)
        !           982:     block = current_binding_level->this_block;
        !           983:   else if (keep || functionbody
        !           984:           || (current_binding_level->keep_if_subblocks && subblocks != 0))
        !           985:     block = make_node (BLOCK);
        !           986:   if (block != 0)
        !           987:     {
        !           988:       BLOCK_VARS (block) = decls;
        !           989:       BLOCK_TYPE_TAGS (block) = tags;
        !           990:       BLOCK_SUBBLOCKS (block) = subblocks;
        !           991:       remember_end_note (block);
        !           992:     }
        !           993: 
        !           994:   /* In each subblock, record that this is its superior.  */
        !           995: 
        !           996:   for (link = subblocks; link; link = TREE_CHAIN (link))
        !           997:     BLOCK_SUPERCONTEXT (link) = block;
        !           998: 
        !           999:   /* Clear out the meanings of the local variables of this level.  */
        !          1000: 
        !          1001:   for (link = decls; link; link = TREE_CHAIN (link))
        !          1002:     {
        !          1003:       if (DECL_NAME (link) != 0)
        !          1004:        {
        !          1005:          /* If the ident. was used or addressed via a local extern decl,
        !          1006:             don't forget that fact.  */
        !          1007:          if (DECL_EXTERNAL (link))
        !          1008:            {
        !          1009:              if (TREE_USED (link))
        !          1010:                TREE_USED (DECL_NAME (link)) = 1;
        !          1011:              if (TREE_ADDRESSABLE (link))
        !          1012:                TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
        !          1013:            }
        !          1014:          IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
        !          1015:        }
        !          1016:     }
        !          1017: 
        !          1018:   /* Restore all name-meanings of the outer levels
        !          1019:      that were shadowed by this level.  */
        !          1020: 
        !          1021:   for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
        !          1022:     IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
        !          1023: 
        !          1024:   /* If the level being exited is the top level of a function,
        !          1025:      check over all the labels, and clear out the current
        !          1026:      (function local) meanings of their names.  */
        !          1027: 
        !          1028:   if (functionbody)
        !          1029:     {
        !          1030:       /* If this is the top level block of a function,
        !          1031:         the vars are the function's parameters.
        !          1032:         Don't leave them in the BLOCK because they are
        !          1033:         found in the FUNCTION_DECL instead.  */
        !          1034: 
        !          1035:       BLOCK_VARS (block) = 0;
        !          1036: 
        !          1037:       /* Clear out the definitions of all label names,
        !          1038:         since their scopes end here,
        !          1039:         and add them to BLOCK_VARS.  */
        !          1040: 
        !          1041:       for (link = named_labels; link; link = TREE_CHAIN (link))
        !          1042:        {
        !          1043:          register tree label = TREE_VALUE (link);
        !          1044: 
        !          1045:          if (DECL_INITIAL (label) == 0)
        !          1046:            {
        !          1047:              error_with_decl (label, "label `%s' used but not defined");
        !          1048:              /* Avoid crashing later.  */
        !          1049:              define_label (input_filename, lineno,
        !          1050:                            DECL_NAME (label));
        !          1051:            }
        !          1052:          else if (warn_unused && !TREE_USED (label))
        !          1053:            warning_with_decl (label, "label `%s' defined but not used");
        !          1054:          IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
        !          1055: 
        !          1056:          /* Put the labels into the "variables" of the
        !          1057:             top-level block, so debugger can see them.  */
        !          1058:          TREE_CHAIN (label) = BLOCK_VARS (block);
        !          1059:          BLOCK_VARS (block) = label;
        !          1060:        }
        !          1061:     }
        !          1062: 
        !          1063:   /* Pop the current level, and free the structure for reuse.  */
        !          1064: 
        !          1065:   {
        !          1066:     register struct binding_level *level = current_binding_level;
        !          1067:     current_binding_level = current_binding_level->level_chain;
        !          1068: 
        !          1069:     level->level_chain = free_binding_level;
        !          1070:     free_binding_level = level;
        !          1071:   }
        !          1072: 
        !          1073:   /* Dispose of the block that we just made inside some higher level.  */
        !          1074:   if (functionbody)
        !          1075:     DECL_INITIAL (current_function_decl) = block;
        !          1076:   else if (block)
        !          1077:     {
        !          1078:       if (!block_previously_created)
        !          1079:         current_binding_level->blocks
        !          1080:           = chainon (current_binding_level->blocks, block);
        !          1081:     }
        !          1082:   /* If we did not make a block for the level just exited,
        !          1083:      any blocks made for inner levels
        !          1084:      (since they cannot be recorded as subblocks in that level)
        !          1085:      must be carried forward so they will later become subblocks
        !          1086:      of something else.  */
        !          1087:   else if (subblocks)
        !          1088:     current_binding_level->blocks
        !          1089:       = chainon (current_binding_level->blocks, subblocks);
        !          1090: 
        !          1091:   /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
        !          1092:      binding contour so that they point to the appropriate construct, i.e.
        !          1093:      either to the current FUNCTION_DECL node, or else to the BLOCK node
        !          1094:      we just constructed.
        !          1095: 
        !          1096:      Note that for tagged types whose scope is just the formal parameter
        !          1097:      list for some function type specification, we can't properly set
        !          1098:      their TYPE_CONTEXTs here, because we don't have a pointer to the
        !          1099:      appropriate FUNCTION_TYPE node readily available to us.  For those
        !          1100:      cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
        !          1101:      in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
        !          1102:      node which will represent the "scope" for these "parameter list local"
        !          1103:      tagged types.
        !          1104:   */
        !          1105: 
        !          1106:   if (functionbody)
        !          1107:     for (link = tags; link; link = TREE_CHAIN (link))
        !          1108:       TYPE_CONTEXT (TREE_VALUE (link)) = current_function_decl;
        !          1109:   else if (block)
        !          1110:     for (link = tags; link; link = TREE_CHAIN (link))
        !          1111:       TYPE_CONTEXT (TREE_VALUE (link)) = block;
        !          1112: 
        !          1113:   if (block)
        !          1114:     TREE_USED (block) = 1;
        !          1115:   return block;
        !          1116: }
        !          1117: 
        !          1118: /* Delete the node BLOCK from the current binding level.
        !          1119:    This is used for the block inside a stmt expr ({...})
        !          1120:    so that the block can be reinserted where appropriate.  */
        !          1121: 
        !          1122: void
        !          1123: delete_block (block)
        !          1124:      tree block;
        !          1125: {
        !          1126:   tree t;
        !          1127:   if (current_binding_level->blocks == block)
        !          1128:     current_binding_level->blocks = TREE_CHAIN (block);
        !          1129:   for (t = current_binding_level->blocks; t;)
        !          1130:     {
        !          1131:       if (TREE_CHAIN (t) == block)
        !          1132:        TREE_CHAIN (t) = TREE_CHAIN (block);
        !          1133:       else
        !          1134:        t = TREE_CHAIN (t);
        !          1135:     }
        !          1136:   TREE_CHAIN (block) = NULL;
        !          1137:   /* Clear TREE_USED which is always set by poplevel.
        !          1138:      The flag is set again if insert_block is called.  */
        !          1139:   TREE_USED (block) = 0;
        !          1140: }
        !          1141: 
        !          1142: /* Insert BLOCK at the end of the list of subblocks of the
        !          1143:    current binding level.  This is used when a BIND_EXPR is expanded,
        !          1144:    to handle the BLOCK node inside the BIND_EXPR.  */
        !          1145: 
        !          1146: void
        !          1147: insert_block (block)
        !          1148:      tree block;
        !          1149: {
        !          1150:   TREE_USED (block) = 1;
        !          1151:   current_binding_level->blocks
        !          1152:     = chainon (current_binding_level->blocks, block);
        !          1153: }
        !          1154: 
        !          1155: /* Set the BLOCK node for the innermost scope
        !          1156:    (the one we are currently in).  */
        !          1157: 
        !          1158: void
        !          1159: set_block (block)
        !          1160:      register tree block;
        !          1161: {
        !          1162:   current_binding_level->this_block = block;
        !          1163: }
        !          1164: 
        !          1165: void
        !          1166: push_label_level ()
        !          1167: {
        !          1168:   register struct binding_level *newlevel;
        !          1169: 
        !          1170:   /* Reuse or create a struct for this binding level.  */
        !          1171: 
        !          1172:   if (free_binding_level)
        !          1173:     {
        !          1174:       newlevel = free_binding_level;
        !          1175:       free_binding_level = free_binding_level->level_chain;
        !          1176:     }
        !          1177:   else
        !          1178:     {
        !          1179:       newlevel = make_binding_level ();
        !          1180:     }
        !          1181: 
        !          1182:   /* Add this level to the front of the chain (stack) of label levels.  */
        !          1183: 
        !          1184:   newlevel->level_chain = label_level_chain;
        !          1185:   label_level_chain = newlevel;
        !          1186: 
        !          1187:   newlevel->names = named_labels;
        !          1188:   newlevel->shadowed = shadowed_labels;
        !          1189:   named_labels = 0;
        !          1190:   shadowed_labels = 0;
        !          1191: }
        !          1192: 
        !          1193: void
        !          1194: pop_label_level ()
        !          1195: {
        !          1196:   register struct binding_level *level = label_level_chain;
        !          1197:   tree link, prev;
        !          1198: 
        !          1199:   /* Clear out the definitions of the declared labels in this level.
        !          1200:      Leave in the list any ordinary, non-declared labels.  */
        !          1201:   for (link = named_labels, prev = 0; link;)
        !          1202:     {
        !          1203:       if (C_DECLARED_LABEL_FLAG (TREE_VALUE (link)))
        !          1204:        {
        !          1205:          if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
        !          1206:            {
        !          1207:              error_with_decl (TREE_VALUE (link),
        !          1208:                               "label `%s' used but not defined");
        !          1209:              /* Avoid crashing later.  */
        !          1210:              define_label (input_filename, lineno,
        !          1211:                            DECL_NAME (TREE_VALUE (link)));
        !          1212:            }
        !          1213:          else if (warn_unused && !TREE_USED (TREE_VALUE (link)))
        !          1214:            warning_with_decl (TREE_VALUE (link), 
        !          1215:                               "label `%s' defined but not used");
        !          1216:          IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
        !          1217: 
        !          1218:          /* Delete this element from the list.  */
        !          1219:          link = TREE_CHAIN (link);
        !          1220:          if (prev)
        !          1221:            TREE_CHAIN (prev) = link;
        !          1222:          else
        !          1223:            named_labels = link;
        !          1224:        }
        !          1225:       else
        !          1226:        {
        !          1227:          prev = link;
        !          1228:          link = TREE_CHAIN (link);
        !          1229:        }
        !          1230:     }
        !          1231: 
        !          1232:   /* Bring back all the labels that were shadowed.  */
        !          1233:   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
        !          1234:     if (DECL_NAME (TREE_VALUE (link)) != 0)
        !          1235:       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
        !          1236:        = TREE_VALUE (link);
        !          1237: 
        !          1238:   named_labels = chainon (named_labels, level->names);
        !          1239:   shadowed_labels = level->shadowed;
        !          1240: 
        !          1241:   /* Pop the current level, and free the structure for reuse.  */
        !          1242:   label_level_chain = label_level_chain->level_chain;
        !          1243:   level->level_chain = free_binding_level;
        !          1244:   free_binding_level = level;
        !          1245: }
        !          1246: 
        !          1247: /* Push a definition or a declaration of struct, union or enum tag "name".
        !          1248:    "type" should be the type node.
        !          1249:    We assume that the tag "name" is not already defined.
        !          1250: 
        !          1251:    Note that the definition may really be just a forward reference.
        !          1252:    In that case, the TYPE_SIZE will be zero.  */
        !          1253: 
        !          1254: void
        !          1255: pushtag (name, type)
        !          1256:      tree name, type;
        !          1257: {
        !          1258:   register struct binding_level *b;
        !          1259: 
        !          1260:   /* Find the proper binding level for this type tag.  */
        !          1261: 
        !          1262:   for (b = current_binding_level; b->tag_transparent; b = b->level_chain)
        !          1263:     continue;
        !          1264: 
        !          1265:   if (name)
        !          1266:     {
        !          1267:       /* Record the identifier as the type's name if it has none.  */
        !          1268: 
        !          1269:       if (TYPE_NAME (type) == 0)
        !          1270:        TYPE_NAME (type) = name;
        !          1271:     }
        !          1272: 
        !          1273:   if (b == global_binding_level)
        !          1274:     b->tags = perm_tree_cons (name, type, b->tags);
        !          1275:   else
        !          1276:     b->tags = saveable_tree_cons (name, type, b->tags);
        !          1277: 
        !          1278:   /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE will be the
        !          1279:      tagged type we just added to the current binding level.  This fake
        !          1280:      NULL-named TYPE_DECL node helps dwarfout.c to know when it needs
        !          1281:      to output a representation of a tagged type, and it also gives
        !          1282:      us a convenient place to record the "scope start" address for the
        !          1283:      tagged type.  */
        !          1284: 
        !          1285:   TYPE_STUB_DECL (type) = pushdecl (build_decl (TYPE_DECL, NULL_TREE, type));
        !          1286: }
        !          1287: 
        !          1288: /* Handle when a new declaration NEWDECL
        !          1289:    has the same name as an old one OLDDECL
        !          1290:    in the same binding contour.
        !          1291:    Prints an error message if appropriate.
        !          1292: 
        !          1293:    If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
        !          1294:    Otherwise, return 0.  */
        !          1295: 
        !          1296: static int
        !          1297: duplicate_decls (newdecl, olddecl)
        !          1298:      register tree newdecl, olddecl;
        !          1299: {
        !          1300:   int types_match = comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
        !          1301:   int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
        !          1302:                           && DECL_INITIAL (newdecl) != 0);
        !          1303:   tree oldtype = TREE_TYPE (olddecl);
        !          1304:   tree newtype = TREE_TYPE (newdecl);
        !          1305: 
        !          1306:   if (TREE_CODE (newtype) == ERROR_MARK
        !          1307:       || TREE_CODE (oldtype) == ERROR_MARK)
        !          1308:     types_match = 0;
        !          1309: 
        !          1310:   /* New decl is completely inconsistent with the old one =>
        !          1311:      tell caller to replace the old one.
        !          1312:      This is always an error except in the case of shadowing a builtin.  */
        !          1313:   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
        !          1314:     {
        !          1315:       if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1316:          && (DECL_BUILT_IN (olddecl)
        !          1317:              || DECL_BUILT_IN_NONANSI (olddecl)))
        !          1318:        {
        !          1319:          /* If you declare a built-in or predefined function name as static,
        !          1320:             the old definition is overridden,
        !          1321:             but optionally warn this was a bad choice of name.  */
        !          1322:          if (!TREE_PUBLIC (newdecl))
        !          1323:            {
        !          1324:              if (!warn_shadow)
        !          1325:                ;
        !          1326:              else if (DECL_BUILT_IN (olddecl))
        !          1327:                warning_with_decl (newdecl, "shadowing built-in function `%s'");
        !          1328:              else
        !          1329:                warning_with_decl (newdecl, "shadowing library function `%s'");
        !          1330:            }
        !          1331:          /* Likewise, if the built-in is not ansi, then programs can
        !          1332:             override it even globally without an error.  */
        !          1333:          else if (! DECL_BUILT_IN (olddecl))
        !          1334:            warning_with_decl (newdecl,
        !          1335:                               "library function `%s' declared as non-function");
        !          1336: 
        !          1337:          else if (DECL_BUILT_IN_NONANSI (olddecl))
        !          1338:            warning_with_decl (newdecl,
        !          1339:                               "built-in function `%s' declared as non-function");
        !          1340:          else
        !          1341:            warning_with_decl (newdecl,
        !          1342:                             "built-in function `%s' declared as non-function");
        !          1343:        }
        !          1344:       else
        !          1345:        {
        !          1346:          error_with_decl (newdecl, "`%s' redeclared as different kind of symbol");
        !          1347:          error_with_decl (olddecl, "previous declaration of `%s'");
        !          1348:        }
        !          1349: 
        !          1350:       return 0;
        !          1351:     }
        !          1352: 
        !          1353:   /* For real parm decl following a forward decl,
        !          1354:      return 1 so old decl will be reused.  */
        !          1355:   if (types_match && TREE_CODE (newdecl) == PARM_DECL
        !          1356:       && TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
        !          1357:     return 1;
        !          1358: 
        !          1359:   /* The new declaration is the same kind of object as the old one.
        !          1360:      The declarations may partially match.  Print warnings if they don't
        !          1361:      match enough.  Ultimately, copy most of the information from the new
        !          1362:      decl to the old one, and keep using the old one.  */
        !          1363: 
        !          1364:   if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
        !          1365:       && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (newdecl)) == olddecl
        !          1366:       && DECL_INITIAL (olddecl) == 0)
        !          1367:     /* If -traditional, avoid error for redeclaring fcn
        !          1368:        after implicit decl.  */
        !          1369:     ;
        !          1370:   else if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1371:           && DECL_BUILT_IN (olddecl))
        !          1372:     {
        !          1373:       /* A function declaration for a built-in function.  */
        !          1374:       if (!TREE_PUBLIC (newdecl))
        !          1375:        {
        !          1376:          /* If you declare a built-in function name as static, the
        !          1377:             built-in definition is overridden,
        !          1378:             but optionally warn this was a bad choice of name.  */
        !          1379:          if (warn_shadow)
        !          1380:            warning_with_decl (newdecl, "shadowing built-in function `%s'");
        !          1381:          /* Discard the old built-in function.  */
        !          1382:          return 0;
        !          1383:        }
        !          1384:       else if (!types_match)
        !          1385:        {
        !          1386:           /* Accept the return type of the new declaration if same modes.  */
        !          1387:          tree oldreturntype = TREE_TYPE (TREE_TYPE (olddecl));
        !          1388:          tree newreturntype = TREE_TYPE (TREE_TYPE (newdecl));
        !          1389:           if (TYPE_MODE (oldreturntype) == TYPE_MODE (newreturntype))
        !          1390:             {
        !          1391:              /* Function types may be shared, so we can't just modify
        !          1392:                 the return type of olddecl's function type.  */
        !          1393:              tree newtype
        !          1394:                = build_function_type (newreturntype,
        !          1395:                                       TYPE_ARG_TYPES (TREE_TYPE (olddecl)));
        !          1396:              
        !          1397:               types_match = comptypes (TREE_TYPE (newdecl), newtype);
        !          1398:              if (types_match)
        !          1399:                TREE_TYPE (olddecl) = newtype;
        !          1400:            }
        !          1401:          /* Accept harmless mismatch in first argument type also.
        !          1402:             This is for ffs.  */
        !          1403:          if (TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0
        !          1404:              && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0
        !          1405:              && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))) != 0
        !          1406:              && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl))) != 0
        !          1407:              && (TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))))
        !          1408:                  ==
        !          1409:                  TYPE_MODE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (olddecl))))))
        !          1410:            {
        !          1411:              /* Function types may be shared, so we can't just modify
        !          1412:                 the return type of olddecl's function type.  */
        !          1413:              tree newtype
        !          1414:                = build_function_type (TREE_TYPE (TREE_TYPE (olddecl)),
        !          1415:                                       tree_cons (NULL_TREE, 
        !          1416:                                                  TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (newdecl))),
        !          1417:                                                  TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (olddecl)))));
        !          1418:              
        !          1419:               types_match = comptypes (TREE_TYPE (newdecl), newtype);
        !          1420:              if (types_match)
        !          1421:                TREE_TYPE (olddecl) = newtype;
        !          1422:            }
        !          1423:        }
        !          1424:       if (!types_match)
        !          1425:        {
        !          1426:          /* If types don't match for a built-in, throw away the built-in.  */
        !          1427:          warning_with_decl (newdecl, "conflicting types for built-in function `%s'");
        !          1428:          return 0;
        !          1429:        }
        !          1430:     }
        !          1431:   else if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1432:           && DECL_SOURCE_LINE (olddecl) == 0)
        !          1433:     {
        !          1434:       /* A function declaration for a predeclared function
        !          1435:         that isn't actually built in.  */
        !          1436:       if (!TREE_PUBLIC (newdecl))
        !          1437:        {
        !          1438:          /* If you declare it as static, the
        !          1439:             default definition is overridden.  */
        !          1440:          return 0;
        !          1441:        }
        !          1442:       else if (!types_match)
        !          1443:        {
        !          1444:          /* If the types don't match, preserve volatility indication.
        !          1445:             Later on, we will discard everything else about the
        !          1446:             default declaration.  */
        !          1447:          TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
        !          1448:        }
        !          1449:     }
        !          1450:   /* Permit char *foo () to match void *foo (...) if not pedantic,
        !          1451:      if one of them came from a system header file.  */
        !          1452:   else if (!types_match
        !          1453:           && TREE_CODE (olddecl) == FUNCTION_DECL
        !          1454:           && TREE_CODE (newdecl) == FUNCTION_DECL
        !          1455:           && TREE_CODE (TREE_TYPE (oldtype)) == POINTER_TYPE
        !          1456:           && TREE_CODE (TREE_TYPE (newtype)) == POINTER_TYPE
        !          1457:           && (DECL_IN_SYSTEM_HEADER (olddecl)
        !          1458:               || DECL_IN_SYSTEM_HEADER (newdecl))
        !          1459:           && ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (newtype))) == void_type_node
        !          1460:                && TYPE_ARG_TYPES (oldtype) == 0
        !          1461:                && self_promoting_args_p (TYPE_ARG_TYPES (newtype))
        !          1462:                && TREE_TYPE (TREE_TYPE (oldtype)) == char_type_node)
        !          1463:               ||
        !          1464:               (TREE_TYPE (TREE_TYPE (newtype)) == char_type_node
        !          1465:                && TYPE_ARG_TYPES (newtype) == 0
        !          1466:                && self_promoting_args_p (TYPE_ARG_TYPES (oldtype))
        !          1467:                && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)))
        !          1468:     {
        !          1469:       if (pedantic)
        !          1470:        pedwarn_with_decl (newdecl, "conflicting types for `%s'");
        !          1471:       /* Make sure we keep void * as ret type, not char *.  */
        !          1472:       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (oldtype))) == void_type_node)
        !          1473:        TREE_TYPE (newdecl) = newtype = oldtype;
        !          1474:     }
        !          1475:   else if (!types_match
        !          1476:           /* Permit char *foo (int, ...); followed by char *foo ();
        !          1477:              if not pedantic.  */
        !          1478:           && ! (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1479:                 && ! pedantic
        !          1480:                 /* Return types must still match.  */
        !          1481:                 && comptypes (TREE_TYPE (oldtype),
        !          1482:                               TREE_TYPE (newtype))
        !          1483:                 && TYPE_ARG_TYPES (newtype) == 0))
        !          1484:     {
        !          1485:       error_with_decl (newdecl, "conflicting types for `%s'");
        !          1486:       /* Check for function type mismatch
        !          1487:         involving an empty arglist vs a nonempty one.  */
        !          1488:       if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1489:          && comptypes (TREE_TYPE (oldtype),
        !          1490:                        TREE_TYPE (newtype))
        !          1491:          && ((TYPE_ARG_TYPES (oldtype) == 0
        !          1492:               && DECL_INITIAL (olddecl) == 0)
        !          1493:              ||
        !          1494:              (TYPE_ARG_TYPES (newtype) == 0
        !          1495:               && DECL_INITIAL (newdecl) == 0)))
        !          1496:        {
        !          1497:          /* Classify the problem further.  */
        !          1498:          register tree t = TYPE_ARG_TYPES (oldtype);
        !          1499:          if (t == 0)
        !          1500:            t = TYPE_ARG_TYPES (newtype);
        !          1501:          for (; t; t = TREE_CHAIN (t))
        !          1502:            {
        !          1503:              register tree type = TREE_VALUE (t);
        !          1504: 
        !          1505:              if (TREE_CHAIN (t) == 0
        !          1506:                  && TYPE_MAIN_VARIANT (type) != void_type_node)
        !          1507:                {
        !          1508:                  error ("A parameter list with an ellipsis can't match");
        !          1509:                  error ("an empty parameter name list declaration.");
        !          1510:                  break;
        !          1511:                }
        !          1512: 
        !          1513:              if (TYPE_MAIN_VARIANT (type) == float_type_node
        !          1514:                  || C_PROMOTING_INTEGER_TYPE_P (type))
        !          1515:                {
        !          1516:                  error ("An argument type that has a default promotion");
        !          1517:                  error ("can't match an empty parameter name list declaration.");
        !          1518:                  break;
        !          1519:                }
        !          1520:            }
        !          1521:        }
        !          1522:       error_with_decl (olddecl, "previous declaration of `%s'");
        !          1523:     }
        !          1524:   else
        !          1525:     {
        !          1526:       char *errmsg = redeclaration_error_message (newdecl, olddecl);
        !          1527:       if (errmsg)
        !          1528:        {
        !          1529:          error_with_decl (newdecl, errmsg);
        !          1530:          error_with_decl (olddecl,
        !          1531:                           ((DECL_INITIAL (olddecl)
        !          1532:                             && current_binding_level == global_binding_level)
        !          1533:                            ? "`%s' previously defined here"
        !          1534:                            : "`%s' previously declared here"));
        !          1535:        }
        !          1536:       else if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1537:               && DECL_INITIAL (olddecl) != 0
        !          1538:               && TYPE_ARG_TYPES (oldtype) == 0
        !          1539:               && TYPE_ARG_TYPES (newtype) != 0)
        !          1540:        {
        !          1541:          register tree type, parm;
        !          1542:          register int nargs;
        !          1543:          /* Prototype decl follows defn w/o prototype.  */
        !          1544: 
        !          1545:          for (parm = TYPE_ACTUAL_ARG_TYPES (oldtype),
        !          1546:               type = TYPE_ARG_TYPES (newtype),
        !          1547:               nargs = 1;
        !          1548:               (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) != void_type_node
        !          1549:                || TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node);
        !          1550:               parm = TREE_CHAIN (parm), type = TREE_CHAIN (type), nargs++)
        !          1551:            {
        !          1552:              if (TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == void_type_node
        !          1553:                  || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
        !          1554:                {
        !          1555:                  errmsg = "prototype for `%s' follows and number of arguments";
        !          1556:                  break;
        !          1557:                }
        !          1558:              /* Type for passing arg must be consistent
        !          1559:                 with that declared for the arg.  */
        !          1560:              if (! comptypes (TREE_VALUE (parm), TREE_VALUE (type))
        !          1561:                  /* If -traditional, allow `unsigned int' instead of `int'
        !          1562:                     in the prototype.  */
        !          1563:                  && (! (flag_traditional
        !          1564:                         && TYPE_MAIN_VARIANT (TREE_VALUE (parm)) == integer_type_node
        !          1565:                         && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node)))
        !          1566:                {
        !          1567:                  errmsg = "prototype for `%s' follows and argument %d";
        !          1568:                  break;
        !          1569:                }
        !          1570:            }
        !          1571:          if (errmsg)
        !          1572:            {
        !          1573:              error_with_decl (newdecl, errmsg, nargs);
        !          1574:              error_with_decl (olddecl,
        !          1575:                               "doesn't match non-prototype definition here");
        !          1576:            }
        !          1577:          else
        !          1578:            {
        !          1579:              warning_with_decl (newdecl, "prototype for `%s' follows");
        !          1580:              warning_with_decl (olddecl, "non-prototype definition here");
        !          1581:            }
        !          1582:        }
        !          1583:       /* Warn about mismatches in various flags.  */
        !          1584:       else
        !          1585:        {
        !          1586:          /* Warn if function is now inline
        !          1587:             but was previously declared not inline and has been called.  */
        !          1588:          if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1589:              && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
        !          1590:              && TREE_USED (olddecl))
        !          1591:            warning_with_decl (newdecl,
        !          1592:                               "`%s' declared inline after being called");
        !          1593:          if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1594:              && ! DECL_INLINE (olddecl) && DECL_INLINE (newdecl)
        !          1595:              && DECL_INITIAL (olddecl) != 0)
        !          1596:            warning_with_decl (newdecl,
        !          1597:                               "`%s' declared inline after its definition");
        !          1598:          /* It is nice to warn when a function is declared
        !          1599:             global first and then static.  */
        !          1600:          if (TREE_CODE (olddecl) == FUNCTION_DECL
        !          1601:              && TREE_PUBLIC (olddecl)
        !          1602:              && !TREE_PUBLIC (newdecl))
        !          1603:            warning_with_decl (newdecl, "static declaration for `%s' follows non-static");
        !          1604: 
        !          1605:          /* These bits are logically part of the type, for variables.
        !          1606:             But not for functions
        !          1607:             (where qualifiers are not valid ANSI anyway).  */
        !          1608:          if (pedantic && TREE_CODE (olddecl) != FUNCTION_DECL
        !          1609:              && (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
        !          1610:                  || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl)))
        !          1611:            pedwarn_with_decl (newdecl, "type qualifiers for `%s' conflict with previous decl");
        !          1612:        }
        !          1613:     }
        !          1614: 
        !          1615:   /* Optionally warn about more than one declaration for the same name.  */
        !          1616:   if (warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
        !          1617:       /* Dont warn about a function declaration
        !          1618:         followed by a definition.  */
        !          1619:       && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
        !          1620:           && DECL_INITIAL (olddecl) == 0)
        !          1621:       /* Don't warn about extern decl followed by (tentative) definition.  */
        !          1622:       && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl)))
        !          1623:     {
        !          1624:       warning_with_decl (newdecl, "redundant redeclaration of `%s' in same scope");
        !          1625:       warning_with_decl (olddecl, "previous declaration of `%s'");
        !          1626:     }
        !          1627: 
        !          1628:   /* Copy all the DECL_... slots specified in the new decl
        !          1629:      except for any that we copy here from the old type.
        !          1630: 
        !          1631:      Past this point, we don't change OLDTYPE and NEWTYPE
        !          1632:      even if we change the types of NEWDECL and OLDDECL.  */
        !          1633: 
        !          1634:   if (types_match)
        !          1635:     {
        !          1636:       /* Merge the data types specified in the two decls.  */
        !          1637:       if (TREE_CODE (newdecl) != FUNCTION_DECL || !DECL_BUILT_IN (olddecl))
        !          1638:        TREE_TYPE (newdecl)
        !          1639:          = TREE_TYPE (olddecl)
        !          1640:            = common_type (newtype, oldtype);
        !          1641: 
        !          1642:       /* Lay the type out, unless already done.  */
        !          1643:       if (oldtype != TREE_TYPE (newdecl))
        !          1644:        {
        !          1645:          if (TREE_TYPE (newdecl) != error_mark_node)
        !          1646:            layout_type (TREE_TYPE (newdecl));
        !          1647:          if (TREE_CODE (newdecl) != FUNCTION_DECL
        !          1648:              && TREE_CODE (newdecl) != TYPE_DECL
        !          1649:              && TREE_CODE (newdecl) != CONST_DECL)
        !          1650:            layout_decl (newdecl, 0);
        !          1651:        }
        !          1652:       else
        !          1653:        {
        !          1654:          /* Since the type is OLDDECL's, make OLDDECL's size go with.  */
        !          1655:          DECL_SIZE (newdecl) = DECL_SIZE (olddecl);
        !          1656:          if (TREE_CODE (olddecl) != FUNCTION_DECL)
        !          1657:            if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
        !          1658:              DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
        !          1659:        }
        !          1660: 
        !          1661:       /* Keep the old rtl since we can safely use it.  */
        !          1662:       DECL_RTL (newdecl) = DECL_RTL (olddecl);
        !          1663: 
        !          1664:       /* Merge the type qualifiers.  */
        !          1665:       if (DECL_BUILT_IN_NONANSI (olddecl) && TREE_THIS_VOLATILE (olddecl)
        !          1666:          && !TREE_THIS_VOLATILE (newdecl))
        !          1667:        TREE_THIS_VOLATILE (olddecl) = 0;
        !          1668:       if (TREE_READONLY (newdecl))
        !          1669:        TREE_READONLY (olddecl) = 1;
        !          1670:       if (TREE_THIS_VOLATILE (newdecl))
        !          1671:        {
        !          1672:          TREE_THIS_VOLATILE (olddecl) = 1;
        !          1673:          if (TREE_CODE (newdecl) == VAR_DECL)
        !          1674:            make_var_volatile (newdecl);
        !          1675:        }
        !          1676: 
        !          1677:       /* Keep source location of definition rather than declaration.  */
        !          1678:       if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
        !          1679:        {
        !          1680:          DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
        !          1681:          DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
        !          1682:        }
        !          1683: 
        !          1684:       /* Merge the unused-warning information.  */
        !          1685:       if (DECL_IN_SYSTEM_HEADER (olddecl))
        !          1686:        DECL_IN_SYSTEM_HEADER (newdecl) = 1;
        !          1687:       else if (DECL_IN_SYSTEM_HEADER (newdecl))
        !          1688:        DECL_IN_SYSTEM_HEADER (olddecl) = 1;
        !          1689: 
        !          1690:       /* Merge the initialization information.  */
        !          1691:       if (DECL_INITIAL (newdecl) == 0)
        !          1692:        DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
        !          1693:     }
        !          1694:   /* If cannot merge, then use the new type and qualifiers,
        !          1695:      and don't preserve the old rtl.  */
        !          1696:   else
        !          1697:     {
        !          1698:       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
        !          1699:       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
        !          1700:       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
        !          1701:       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
        !          1702:     }
        !          1703: 
        !          1704:   /* Merge the storage class information.  */
        !          1705:   /* For functions, static overrides non-static.  */
        !          1706:   if (TREE_CODE (newdecl) == FUNCTION_DECL)
        !          1707:     {
        !          1708:       TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
        !          1709:       /* This is since we don't automatically
        !          1710:         copy the attributes of NEWDECL into OLDDECL.  */
        !          1711:       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
        !          1712:       /* If this clears `static', clear it in the identifier too.  */
        !          1713:       if (! TREE_PUBLIC (olddecl))
        !          1714:        TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
        !          1715:     }
        !          1716:   if (DECL_EXTERNAL (newdecl))
        !          1717:     {
        !          1718:       TREE_STATIC (newdecl) = TREE_STATIC (olddecl);
        !          1719:       DECL_EXTERNAL (newdecl) = DECL_EXTERNAL (olddecl);
        !          1720:       /* An extern decl does not override previous storage class.  */
        !          1721:       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
        !          1722:     }
        !          1723:   else
        !          1724:     {
        !          1725:       TREE_STATIC (olddecl) = TREE_STATIC (newdecl);
        !          1726:       TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
        !          1727:     }
        !          1728: 
        !          1729:   /* If either decl says `inline', this fn is inline,
        !          1730:      unless its definition was passed already.  */
        !          1731:   if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == 0)
        !          1732:     DECL_INLINE (olddecl) = 1;
        !          1733:   DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
        !          1734: 
        !          1735:   /* Get rid of any built-in function if new arg types don't match it
        !          1736:      or if we have a function definition.  */
        !          1737:   if (TREE_CODE (newdecl) == FUNCTION_DECL
        !          1738:       && DECL_BUILT_IN (olddecl)
        !          1739:       && (!types_match || new_is_definition))
        !          1740:     {
        !          1741:       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
        !          1742:       DECL_BUILT_IN (olddecl) = 0;
        !          1743:     }
        !          1744: 
        !          1745:   /* If redeclaring a builtin function, and not a definition,
        !          1746:      it stays built in.
        !          1747:      Also preserve various other info from the definition.  */
        !          1748:   if (TREE_CODE (newdecl) == FUNCTION_DECL && !new_is_definition)
        !          1749:     {
        !          1750:       if (DECL_BUILT_IN (olddecl))
        !          1751:        {
        !          1752:          DECL_BUILT_IN (newdecl) = 1;
        !          1753:          DECL_SET_FUNCTION_CODE (newdecl, DECL_FUNCTION_CODE (olddecl));
        !          1754:        }
        !          1755:       else
        !          1756:        DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
        !          1757: 
        !          1758:       DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
        !          1759:       DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
        !          1760:       DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
        !          1761:       DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
        !          1762:     }
        !          1763: 
        !          1764:   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
        !          1765:      But preserve OLDdECL's DECL_UID.  */
        !          1766:   {
        !          1767:     register unsigned olddecl_uid = DECL_UID (olddecl);
        !          1768: 
        !          1769:     bcopy ((char *) newdecl + sizeof (struct tree_common),
        !          1770:           (char *) olddecl + sizeof (struct tree_common),
        !          1771:           sizeof (struct tree_decl) - sizeof (struct tree_common));
        !          1772:     DECL_UID (olddecl) = olddecl_uid;
        !          1773:   }
        !          1774: 
        !          1775:   return 1;
        !          1776: }
        !          1777: 
        !          1778: /* Record a decl-node X as belonging to the current lexical scope.
        !          1779:    Check for errors (such as an incompatible declaration for the same
        !          1780:    name already seen in the same scope).
        !          1781: 
        !          1782:    Returns either X or an old decl for the same name.
        !          1783:    If an old decl is returned, it may have been smashed
        !          1784:    to agree with what X says.  */
        !          1785: 
        !          1786: tree
        !          1787: pushdecl (x)
        !          1788:      tree x;
        !          1789: {
        !          1790:   register tree t;
        !          1791:   register tree name = DECL_NAME (x);
        !          1792:   register struct binding_level *b = current_binding_level;
        !          1793: 
        !          1794:   DECL_CONTEXT (x) = current_function_decl;
        !          1795:   /* A local extern declaration for a function doesn't constitute nesting.
        !          1796:      A local auto declaration does, since it's a forward decl
        !          1797:      for a nested function coming later.  */
        !          1798:   if (TREE_CODE (x) == FUNCTION_DECL && DECL_INITIAL (x) == 0
        !          1799:       && DECL_EXTERNAL (x))
        !          1800:     DECL_CONTEXT (x) = 0;
        !          1801: 
        !          1802:   if (warn_nested_externs && DECL_EXTERNAL (x) && b != global_binding_level
        !          1803:       && x != IDENTIFIER_IMPLICIT_DECL (name)
        !          1804:       /* Don't print error messages for __FUNCTION__ and __PRETTY_FUNCTION__ */
        !          1805:       && !DECL_IN_SYSTEM_HEADER (x))
        !          1806:     warning ("nested extern declaration of `%s'", IDENTIFIER_POINTER (name));
        !          1807: 
        !          1808:   if (name)
        !          1809:     {
        !          1810:       char *file;
        !          1811:       int line;
        !          1812: 
        !          1813:       t = lookup_name_current_level (name);
        !          1814:       if (t != 0 && t == error_mark_node)
        !          1815:        /* error_mark_node is 0 for a while during initialization!  */
        !          1816:        {
        !          1817:          t = 0;
        !          1818:          error_with_decl (x, "`%s' used prior to declaration");
        !          1819:        }
        !          1820: 
        !          1821:       if (t != 0)
        !          1822:        {
        !          1823:          file = DECL_SOURCE_FILE (t);
        !          1824:          line = DECL_SOURCE_LINE (t);
        !          1825:        }
        !          1826: 
        !          1827:       if (t != 0 && duplicate_decls (x, t))
        !          1828:        {
        !          1829:          if (TREE_CODE (t) == PARM_DECL)
        !          1830:            {
        !          1831:              /* Don't allow more than one "real" duplicate
        !          1832:                 of a forward parm decl.  */
        !          1833:              TREE_ASM_WRITTEN (t) = TREE_ASM_WRITTEN (x);
        !          1834:              return t;
        !          1835:            }
        !          1836:          /* If this decl is `static' and an implicit decl was seen previously,
        !          1837:             warn.  But don't complain if -traditional,
        !          1838:             since traditional compilers don't complain.  */
        !          1839:          if (!flag_traditional && TREE_PUBLIC (name)
        !          1840:              && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x)
        !          1841:              /* We used to warn also for explicit extern followed by static,
        !          1842:                 but sometimes you need to do it that way.  */
        !          1843:              && IDENTIFIER_IMPLICIT_DECL (name) != 0)
        !          1844:            {
        !          1845:              pedwarn ("`%s' was declared implicitly `extern' and later `static'",
        !          1846:                       IDENTIFIER_POINTER (name));
        !          1847:              pedwarn_with_file_and_line (file, line,
        !          1848:                                          "previous declaration of `%s'",
        !          1849:                                          IDENTIFIER_POINTER (name));
        !          1850:            }
        !          1851: 
        !          1852:          return t;
        !          1853:        }
        !          1854: 
        !          1855:       /* If we are processing a typedef statement, generate a whole new
        !          1856:         ..._TYPE node (which will be just an variant of the existing
        !          1857:         ..._TYPE node with identical properties) and then install the
        !          1858:         TYPE_DECL node generated to represent the typedef name as the
        !          1859:         TYPE_NAME of this brand new (duplicate) ..._TYPE node.
        !          1860: 
        !          1861:         The whole point here is to end up with a situation where each
        !          1862:         and every ..._TYPE node the compiler creates will be uniquely
        !          1863:         associated with AT MOST one node representing a typedef name.
        !          1864:         This way, even though the compiler substitutes corresponding
        !          1865:         ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
        !          1866:         early on, later parts of the compiler can always do the reverse
        !          1867:         translation and get back the corresponding typedef name.  For
        !          1868:         example, given:
        !          1869: 
        !          1870:                typedef struct S MY_TYPE;
        !          1871:                MY_TYPE object;
        !          1872: 
        !          1873:         Later parts of the compiler might only know that `object' was of
        !          1874:         type `struct S' if if were not for code just below.  With this
        !          1875:         code however, later parts of the compiler see something like:
        !          1876: 
        !          1877:                struct S' == struct S
        !          1878:                typedef struct S' MY_TYPE;
        !          1879:                struct S' object;
        !          1880: 
        !          1881:         And they can then deduce (from the node for type struct S') that
        !          1882:         the original object declaration was:
        !          1883: 
        !          1884:                MY_TYPE object;
        !          1885: 
        !          1886:         Being able to do this is important for proper support of protoize,
        !          1887:         and also for generating precise symbolic debugging information
        !          1888:         which takes full account of the programmer's (typedef) vocabulary.
        !          1889: 
        !          1890:          Obviously, we don't want to generate a duplicate ..._TYPE node if
        !          1891:         the TYPE_DECL node that we are now processing really represents a
        !          1892:         standard built-in type.
        !          1893: 
        !          1894:          Since all standard types are effectively declared at line zero
        !          1895:          in the source file, we can easily check to see if we are working
        !          1896:          on a standard type by checking the current value of lineno.  */
        !          1897: 
        !          1898:       if (TREE_CODE (x) == TYPE_DECL)
        !          1899:         {
        !          1900:           if (DECL_SOURCE_LINE (x) == 0)
        !          1901:             {
        !          1902:              if (TYPE_NAME (TREE_TYPE (x)) == 0)
        !          1903:                TYPE_NAME (TREE_TYPE (x)) = x;
        !          1904:             }
        !          1905:           else if (TREE_TYPE (x) != error_mark_node)
        !          1906:             {
        !          1907:               tree tt = TREE_TYPE (x);
        !          1908: 
        !          1909:               tt = build_type_copy (tt);
        !          1910:               TYPE_NAME (tt) = x;
        !          1911:               TREE_TYPE (x) = tt;
        !          1912:             }
        !          1913:         }
        !          1914: 
        !          1915:       /* Multiple external decls of the same identifier ought to match.
        !          1916:         Check against both global declarations and out of scope (limbo) block
        !          1917:         level declarations.
        !          1918: 
        !          1919:         We get warnings about inline functions where they are defined.
        !          1920:         Avoid duplicate warnings where they are used.  */
        !          1921:       if (TREE_PUBLIC (x) && ! DECL_INLINE (x))
        !          1922:        {
        !          1923:          tree decl;
        !          1924: 
        !          1925:          if (IDENTIFIER_GLOBAL_VALUE (name) != 0
        !          1926:              && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name))
        !          1927:                  || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name))))
        !          1928:            decl = IDENTIFIER_GLOBAL_VALUE (name);
        !          1929:          else if (IDENTIFIER_LIMBO_VALUE (name) != 0)
        !          1930:            /* Decls in limbo are always extern, so no need to check that.  */
        !          1931:            decl = IDENTIFIER_LIMBO_VALUE (name);
        !          1932:          else
        !          1933:            decl = 0;
        !          1934: 
        !          1935:          if (decl && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl))
        !          1936:              /* If old decl is built-in, we already warned if we should.  */
        !          1937:              && !DECL_BUILT_IN (decl))
        !          1938:            {
        !          1939:              pedwarn_with_decl (x,
        !          1940:                                 "type mismatch with previous external decl");
        !          1941:              pedwarn_with_decl (decl, "previous external decl of `%s'");
        !          1942:            }
        !          1943:        }
        !          1944: 
        !          1945:       /* If a function has had an implicit declaration, and then is defined,
        !          1946:         make sure they are compatible.  */
        !          1947: 
        !          1948:       if (IDENTIFIER_IMPLICIT_DECL (name) != 0
        !          1949:          && IDENTIFIER_GLOBAL_VALUE (name) == 0
        !          1950:          && TREE_CODE (x) == FUNCTION_DECL
        !          1951:          && ! comptypes (TREE_TYPE (x),
        !          1952:                          TREE_TYPE (IDENTIFIER_IMPLICIT_DECL (name))))
        !          1953:        {
        !          1954:          warning_with_decl (x, "type mismatch with previous implicit declaration");
        !          1955:          warning_with_decl (IDENTIFIER_IMPLICIT_DECL (name),
        !          1956:                             "previous implicit declaration of `%s'");
        !          1957:        }
        !          1958: 
        !          1959:       /* In PCC-compatibility mode, extern decls of vars with no current decl
        !          1960:         take effect at top level no matter where they are.  */
        !          1961:       if (flag_traditional && DECL_EXTERNAL (x)
        !          1962:          && lookup_name (name) == 0)
        !          1963:        {
        !          1964:          tree type = TREE_TYPE (x);
        !          1965: 
        !          1966:          /* But don't do this if the type contains temporary nodes.  */
        !          1967:          while (type)
        !          1968:            {
        !          1969:              if (type == error_mark_node)
        !          1970:                break;
        !          1971:              if (! TREE_PERMANENT (type))
        !          1972:                {
        !          1973:                  warning_with_decl (x, "type of external `%s' is not global");
        !          1974:                  /* By exiting the loop early, we leave TYPE nonzero,
        !          1975:                     and thus prevent globalization of the decl.  */
        !          1976:                  break;
        !          1977:                }
        !          1978:              else if (TREE_CODE (type) == FUNCTION_TYPE
        !          1979:                       && TYPE_ARG_TYPES (type) != 0)
        !          1980:                /* The types might not be truly local,
        !          1981:                   but the list of arg types certainly is temporary.
        !          1982:                   Since prototypes are nontraditional,
        !          1983:                   ok not to do the traditional thing.  */
        !          1984:                break;
        !          1985:              type = TREE_TYPE (type);
        !          1986:            }
        !          1987: 
        !          1988:          if (type == 0)
        !          1989:            b = global_binding_level;
        !          1990:        }
        !          1991: 
        !          1992:       /* This name is new in its binding level.
        !          1993:         Install the new declaration and return it.  */
        !          1994:       if (b == global_binding_level)
        !          1995:        {
        !          1996:          /* Install a global value.  */
        !          1997:          
        !          1998:          /* If the first global decl has external linkage,
        !          1999:             warn if we later see static one.  */
        !          2000:          if (IDENTIFIER_GLOBAL_VALUE (name) == 0 && TREE_PUBLIC (x))
        !          2001:            TREE_PUBLIC (name) = 1;
        !          2002: 
        !          2003:          IDENTIFIER_GLOBAL_VALUE (name) = x;
        !          2004: 
        !          2005:          /* We no longer care about any previous block level declarations.  */
        !          2006:          IDENTIFIER_LIMBO_VALUE (name) = 0;
        !          2007: 
        !          2008:          /* Don't forget if the function was used via an implicit decl.  */
        !          2009:          if (IDENTIFIER_IMPLICIT_DECL (name)
        !          2010:              && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
        !          2011:            TREE_USED (x) = 1, TREE_USED (name) = 1;
        !          2012: 
        !          2013:          /* Don't forget if its address was taken in that way.  */
        !          2014:          if (IDENTIFIER_IMPLICIT_DECL (name)
        !          2015:              && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
        !          2016:            TREE_ADDRESSABLE (x) = 1;
        !          2017: 
        !          2018:          /* Warn about mismatches against previous implicit decl.  */
        !          2019:          if (IDENTIFIER_IMPLICIT_DECL (name) != 0
        !          2020:              /* If this real decl matches the implicit, don't complain.  */
        !          2021:              && ! (TREE_CODE (x) == FUNCTION_DECL
        !          2022:                    && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (x)))
        !          2023:                        == integer_type_node)))
        !          2024:            pedwarn ("`%s' was previously implicitly declared to return `int'",
        !          2025:                     IDENTIFIER_POINTER (name));
        !          2026: 
        !          2027:          /* If this decl is `static' and an `extern' was seen previously,
        !          2028:             that is erroneous.  */
        !          2029:          if (TREE_PUBLIC (name)
        !          2030:              && ! TREE_PUBLIC (x) && ! DECL_EXTERNAL (x))
        !          2031:            {
        !          2032:              /* Okay to redeclare an ANSI built-in as static.  */
        !          2033:              if (t != 0 && DECL_BUILT_IN (t))
        !          2034:                ;
        !          2035:              /* Okay to declare a non-ANSI built-in as anything.  */
        !          2036:              else if (t != 0 && DECL_BUILT_IN_NONANSI (t))
        !          2037:                ;
        !          2038:              else if (IDENTIFIER_IMPLICIT_DECL (name))
        !          2039:                pedwarn ("`%s' was declared implicitly `extern' and later `static'",
        !          2040:                         IDENTIFIER_POINTER (name));
        !          2041:              else
        !          2042:                pedwarn ("`%s' was declared `extern' and later `static'",
        !          2043:                         IDENTIFIER_POINTER (name));
        !          2044:            }
        !          2045:        }
        !          2046:       else
        !          2047:        {
        !          2048:          /* Here to install a non-global value.  */
        !          2049:          tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
        !          2050:          tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
        !          2051:          IDENTIFIER_LOCAL_VALUE (name) = x;
        !          2052: 
        !          2053:          /* If this is an extern function declaration, see if we
        !          2054:             have a global definition or declaration for the function.  */
        !          2055:          if (oldlocal == 0
        !          2056:              && DECL_EXTERNAL (x) && !DECL_INLINE (x)
        !          2057:              && oldglobal != 0
        !          2058:              && TREE_CODE (x) == FUNCTION_DECL
        !          2059:              && TREE_CODE (oldglobal) == FUNCTION_DECL)
        !          2060:            {
        !          2061:              /* We have one.  Their types must agree.  */
        !          2062:              if (! comptypes (TREE_TYPE (x),
        !          2063:                               TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
        !          2064:                pedwarn_with_decl (x, "extern declaration of `%s' doesn't match global one");
        !          2065:              else
        !          2066:                {
        !          2067:                  /* Inner extern decl is inline if global one is.
        !          2068:                     Copy enough to really inline it.  */
        !          2069:                  if (DECL_INLINE (oldglobal))
        !          2070:                    {
        !          2071:                      DECL_INLINE (x) = DECL_INLINE (oldglobal);
        !          2072:                      DECL_INITIAL (x) = (current_function_decl == oldglobal
        !          2073:                                          ? 0 : DECL_INITIAL (oldglobal));
        !          2074:                      DECL_SAVED_INSNS (x) = DECL_SAVED_INSNS (oldglobal);
        !          2075:                      DECL_FRAME_SIZE (x) = DECL_FRAME_SIZE (oldglobal);
        !          2076:                      DECL_ARGUMENTS (x) = DECL_ARGUMENTS (oldglobal);
        !          2077:                      DECL_RESULT (x) = DECL_RESULT (oldglobal);
        !          2078:                      TREE_ASM_WRITTEN (x) = TREE_ASM_WRITTEN (oldglobal);
        !          2079:                      DECL_ABSTRACT_ORIGIN (x) = oldglobal;
        !          2080:                    }
        !          2081:                  /* Inner extern decl is built-in if global one is.  */
        !          2082:                  if (DECL_BUILT_IN (oldglobal))
        !          2083:                    {
        !          2084:                      DECL_BUILT_IN (x) = DECL_BUILT_IN (oldglobal);
        !          2085:                      DECL_SET_FUNCTION_CODE (x, DECL_FUNCTION_CODE (oldglobal));
        !          2086:                    }
        !          2087:                  /* Keep the arg types from a file-scope fcn defn.  */
        !          2088:                  if (TYPE_ARG_TYPES (TREE_TYPE (oldglobal)) != 0
        !          2089:                      && DECL_INITIAL (oldglobal)
        !          2090:                      && TYPE_ARG_TYPES (TREE_TYPE (x)) == 0)
        !          2091:                    TREE_TYPE (x) = TREE_TYPE (oldglobal);
        !          2092:                }
        !          2093:            }
        !          2094: 
        !          2095: #if 0 /* This case is probably sometimes the right thing to do.  */
        !          2096:          /* If we have a local external declaration,
        !          2097:             then any file-scope declaration should not
        !          2098:             have been static.  */
        !          2099:          if (oldlocal == 0 && oldglobal != 0
        !          2100:              && !TREE_PUBLIC (oldglobal)
        !          2101:              && DECL_EXTERNAL (x) && TREE_PUBLIC (x))
        !          2102:            warning ("`%s' locally external but globally static",
        !          2103:                     IDENTIFIER_POINTER (name));
        !          2104: #endif
        !          2105: 
        !          2106:          /* If we have a local external declaration,
        !          2107:             and no file-scope declaration has yet been seen,
        !          2108:             then if we later have a file-scope decl it must not be static.  */
        !          2109:          if (oldlocal == 0
        !          2110:              && oldglobal == 0
        !          2111:              && DECL_EXTERNAL (x)
        !          2112:              && TREE_PUBLIC (x))
        !          2113:            {
        !          2114:              TREE_PUBLIC (name) = 1;
        !          2115: 
        !          2116:              /* Save this decl, so that we can do type checking against
        !          2117:                 other decls after it falls out of scope.
        !          2118: 
        !          2119:                 Only save it once.  This prevents temporary decls created in
        !          2120:                 expand_inline_function from being used here, since this
        !          2121:                 will have been set when the inline function was parsed.
        !          2122:                 It also helps give slightly better warnings.  */
        !          2123:              if (IDENTIFIER_LIMBO_VALUE (name) == 0)
        !          2124:                IDENTIFIER_LIMBO_VALUE (name) = x;
        !          2125:            }
        !          2126: 
        !          2127:          /* Warn if shadowing an argument at the top level of the body.  */
        !          2128:          if (oldlocal != 0 && !DECL_EXTERNAL (x)
        !          2129:              /* This warning doesn't apply to the parms of a nested fcn.  */
        !          2130:              && ! current_binding_level->parm_flag
        !          2131:              /* Check that this is one level down from the parms.  */
        !          2132:              && current_binding_level->level_chain->parm_flag
        !          2133:              /* Check that the decl being shadowed
        !          2134:                 comes from the parm level, one level up.  */
        !          2135:              && chain_member (oldlocal, current_binding_level->level_chain->names))
        !          2136:            {
        !          2137:              if (TREE_CODE (oldlocal) == PARM_DECL)
        !          2138:                pedwarn ("declaration of `%s' shadows a parameter",
        !          2139:                         IDENTIFIER_POINTER (name));
        !          2140:              else
        !          2141:                pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
        !          2142:                         IDENTIFIER_POINTER (name));
        !          2143:            }
        !          2144: 
        !          2145:          /* Maybe warn if shadowing something else.  */
        !          2146:          else if (warn_shadow && !DECL_EXTERNAL (x)
        !          2147:                   /* No shadow warnings for internally generated vars.  */
        !          2148:                   && DECL_SOURCE_LINE (x) != 0
        !          2149:                   /* No shadow warnings for vars made for inlining.  */
        !          2150:                   && ! DECL_FROM_INLINE (x))
        !          2151:            {
        !          2152:              char *warnstring = 0;
        !          2153: 
        !          2154:              if (TREE_CODE (x) == PARM_DECL
        !          2155:                  && current_binding_level->level_chain->parm_flag)
        !          2156:                /* Don't warn about the parm names in function declarator
        !          2157:                   within a function declarator.
        !          2158:                   It would be nice to avoid warning in any function
        !          2159:                   declarator in a declaration, as opposed to a definition,
        !          2160:                   but there is no way to tell it's not a definition.  */
        !          2161:                ;
        !          2162:              else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
        !          2163:                warnstring = "declaration of `%s' shadows a parameter";
        !          2164:              else if (oldlocal != 0)
        !          2165:                warnstring = "declaration of `%s' shadows previous local";
        !          2166:              else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
        !          2167:                       && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
        !          2168:                warnstring = "declaration of `%s' shadows global declaration";
        !          2169: 
        !          2170:              if (warnstring)
        !          2171:                warning (warnstring, IDENTIFIER_POINTER (name));
        !          2172:            }
        !          2173: 
        !          2174:          /* If storing a local value, there may already be one (inherited).
        !          2175:             If so, record it for restoration when this binding level ends.  */
        !          2176:          if (oldlocal != 0)
        !          2177:            b->shadowed = tree_cons (name, oldlocal, b->shadowed);
        !          2178:        }
        !          2179: 
        !          2180:       /* Keep count of variables in this level with incomplete type.  */
        !          2181:       if (TYPE_SIZE (TREE_TYPE (x)) == 0)
        !          2182:        ++b->n_incomplete;
        !          2183:     }
        !          2184: 
        !          2185:   /* Put decls on list in reverse order.
        !          2186:      We will reverse them later if necessary.  */
        !          2187:   TREE_CHAIN (x) = b->names;
        !          2188:   b->names = x;
        !          2189: 
        !          2190:   return x;
        !          2191: }
        !          2192: 
        !          2193: /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate.  */
        !          2194: 
        !          2195: tree
        !          2196: pushdecl_top_level (x)
        !          2197:      tree x;
        !          2198: {
        !          2199:   register tree t;
        !          2200:   register struct binding_level *b = current_binding_level;
        !          2201:   register tree function_decl = current_function_decl;
        !          2202: 
        !          2203:   current_binding_level = global_binding_level;
        !          2204:   current_function_decl = 0;
        !          2205:   t = pushdecl (x);
        !          2206:   current_binding_level = b;
        !          2207:   current_function_decl = function_decl;
        !          2208:   return t;
        !          2209: }
        !          2210: 
        !          2211: /* Generate an implicit declaration for identifier FUNCTIONID
        !          2212:    as a function of type int ().  Print a warning if appropriate.  */
        !          2213: 
        !          2214: tree
        !          2215: implicitly_declare (functionid)
        !          2216:      tree functionid;
        !          2217: {
        !          2218:   register tree decl;
        !          2219:   int traditional_warning = 0;
        !          2220:   /* Only one "implicit declaration" warning per identifier.  */
        !          2221:   int implicit_warning;
        !          2222: 
        !          2223:   /* Save the decl permanently so we can warn if definition follows.  */
        !          2224:   push_obstacks_nochange ();
        !          2225:   end_temporary_allocation ();
        !          2226: 
        !          2227:   /* We used to reuse an old implicit decl here,
        !          2228:      but this loses with inline functions because it can clobber
        !          2229:      the saved decl chains.  */
        !          2230: /*  if (IDENTIFIER_IMPLICIT_DECL (functionid) != 0)
        !          2231:     decl = IDENTIFIER_IMPLICIT_DECL (functionid);
        !          2232:   else  */
        !          2233:     decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
        !          2234: 
        !          2235:   /* Warn of implicit decl following explicit local extern decl.
        !          2236:      This is probably a program designed for traditional C.  */
        !          2237:   if (TREE_PUBLIC (functionid) && IDENTIFIER_GLOBAL_VALUE (functionid) == 0)
        !          2238:     traditional_warning = 1;
        !          2239: 
        !          2240:   /* Warn once of an implicit declaration.  */
        !          2241:   implicit_warning = (IDENTIFIER_IMPLICIT_DECL (functionid) == 0);
        !          2242: 
        !          2243:   DECL_EXTERNAL (decl) = 1;
        !          2244:   TREE_PUBLIC (decl) = 1;
        !          2245: 
        !          2246:   /* Record that we have an implicit decl and this is it.  */
        !          2247:   IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
        !          2248: 
        !          2249:   /* ANSI standard says implicit declarations are in the innermost block.
        !          2250:      So we record the decl in the standard fashion.
        !          2251:      If flag_traditional is set, pushdecl does it top-level.  */
        !          2252:   pushdecl (decl);
        !          2253: 
        !          2254:   /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
        !          2255:   maybe_objc_check_decl (decl);
        !          2256: 
        !          2257:   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
        !          2258: 
        !          2259:   if (warn_implicit && implicit_warning)
        !          2260:     warning ("implicit declaration of function `%s'",
        !          2261:             IDENTIFIER_POINTER (functionid));
        !          2262:   else if (warn_traditional && traditional_warning)
        !          2263:     warning ("function `%s' was previously declared within a block",
        !          2264:             IDENTIFIER_POINTER (functionid));
        !          2265: 
        !          2266:   /* Write a record describing this implicit function declaration to the
        !          2267:      prototypes file (if requested).  */
        !          2268: 
        !          2269:   gen_aux_info_record (decl, 0, 1, 0);
        !          2270: 
        !          2271:   pop_obstacks ();
        !          2272: 
        !          2273:   return decl;
        !          2274: }
        !          2275: 
        !          2276: /* Return zero if the declaration NEWDECL is valid
        !          2277:    when the declaration OLDDECL (assumed to be for the same name)
        !          2278:    has already been seen.
        !          2279:    Otherwise return an error message format string with a %s
        !          2280:    where the identifier should go.  */
        !          2281: 
        !          2282: static char *
        !          2283: redeclaration_error_message (newdecl, olddecl)
        !          2284:      tree newdecl, olddecl;
        !          2285: {
        !          2286:   if (TREE_CODE (newdecl) == TYPE_DECL)
        !          2287:     {
        !          2288:       if (flag_traditional && TREE_TYPE (newdecl) == TREE_TYPE (olddecl))
        !          2289:        return 0;
        !          2290:       return "redefinition of `%s'";
        !          2291:     }
        !          2292:   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
        !          2293:     {
        !          2294:       /* Declarations of functions can insist on internal linkage
        !          2295:         but they can't be inconsistent with internal linkage,
        !          2296:         so there can be no error on that account.
        !          2297:         However defining the same name twice is no good.  */
        !          2298:       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0
        !          2299:          /* However, defining once as extern inline and a second
        !          2300:             time in another way is ok.  */
        !          2301:          && !(DECL_INLINE (olddecl) && DECL_EXTERNAL (olddecl)
        !          2302:               && !(DECL_INLINE (newdecl) && DECL_EXTERNAL (newdecl))))
        !          2303:        return "redefinition of `%s'";
        !          2304:       return 0;
        !          2305:     }
        !          2306:   else if (current_binding_level == global_binding_level)
        !          2307:     {
        !          2308:       /* Objects declared at top level:  */
        !          2309:       /* If at least one is a reference, it's ok.  */
        !          2310:       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
        !          2311:        return 0;
        !          2312:       /* Reject two definitions.  */
        !          2313:       if (DECL_INITIAL (olddecl) != 0 && DECL_INITIAL (newdecl) != 0)
        !          2314:        return "redefinition of `%s'";
        !          2315:       /* Now we have two tentative defs, or one tentative and one real def.  */
        !          2316:       /* Insist that the linkage match.  */
        !          2317:       if (TREE_PUBLIC (olddecl) != TREE_PUBLIC (newdecl))
        !          2318:        return "conflicting declarations of `%s'";
        !          2319:       return 0;
        !          2320:     }
        !          2321:   else if (current_binding_level->parm_flag
        !          2322:           && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
        !          2323:     return 0;
        !          2324:   else
        !          2325:     {
        !          2326:       /* Objects declared with block scope:  */
        !          2327:       /* Reject two definitions, and reject a definition
        !          2328:         together with an external reference.  */
        !          2329:       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
        !          2330:        return "redeclaration of `%s'";
        !          2331:       return 0;
        !          2332:     }
        !          2333: }
        !          2334: 
        !          2335: /* Get the LABEL_DECL corresponding to identifier ID as a label.
        !          2336:    Create one if none exists so far for the current function.
        !          2337:    This function is called for both label definitions and label references.  */
        !          2338: 
        !          2339: tree
        !          2340: lookup_label (id)
        !          2341:      tree id;
        !          2342: {
        !          2343:   register tree decl = IDENTIFIER_LABEL_VALUE (id);
        !          2344: 
        !          2345:   if (current_function_decl == 0)
        !          2346:     {
        !          2347:       error ("label %s referenced outside of any function",
        !          2348:             IDENTIFIER_POINTER (id));
        !          2349:       return 0;
        !          2350:     }
        !          2351: 
        !          2352:   /* Use a label already defined or ref'd with this name.  */
        !          2353:   if (decl != 0)
        !          2354:     {
        !          2355:       /* But not if it is inherited and wasn't declared to be inheritable.  */
        !          2356:       if (DECL_CONTEXT (decl) != current_function_decl
        !          2357:          && ! C_DECLARED_LABEL_FLAG (decl))
        !          2358:        return shadow_label (id);
        !          2359:       return decl;
        !          2360:     }
        !          2361: 
        !          2362:   decl = build_decl (LABEL_DECL, id, void_type_node);
        !          2363: 
        !          2364:   /* Make sure every label has an rtx.  */
        !          2365:   label_rtx (decl);
        !          2366: 
        !          2367:   /* A label not explicitly declared must be local to where it's ref'd.  */
        !          2368:   DECL_CONTEXT (decl) = current_function_decl;
        !          2369: 
        !          2370:   DECL_MODE (decl) = VOIDmode;
        !          2371: 
        !          2372:   /* Say where one reference is to the label,
        !          2373:      for the sake of the error if it is not defined.  */
        !          2374:   DECL_SOURCE_LINE (decl) = lineno;
        !          2375:   DECL_SOURCE_FILE (decl) = input_filename;
        !          2376: 
        !          2377:   IDENTIFIER_LABEL_VALUE (id) = decl;
        !          2378: 
        !          2379:   named_labels = tree_cons (NULL_TREE, decl, named_labels);
        !          2380: 
        !          2381:   return decl;
        !          2382: }
        !          2383: 
        !          2384: /* Make a label named NAME in the current function,
        !          2385:    shadowing silently any that may be inherited from containing functions
        !          2386:    or containing scopes.
        !          2387: 
        !          2388:    Note that valid use, if the label being shadowed
        !          2389:    comes from another scope in the same function,
        !          2390:    requires calling declare_nonlocal_label right away.  */
        !          2391: 
        !          2392: tree
        !          2393: shadow_label (name)
        !          2394:      tree name;
        !          2395: {
        !          2396:   register tree decl = IDENTIFIER_LABEL_VALUE (name);
        !          2397: 
        !          2398:   if (decl != 0)
        !          2399:     {
        !          2400:       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
        !          2401:       IDENTIFIER_LABEL_VALUE (name) = decl = 0;
        !          2402:     }
        !          2403: 
        !          2404:   return lookup_label (name);
        !          2405: }
        !          2406: 
        !          2407: /* Define a label, specifying the location in the source file.
        !          2408:    Return the LABEL_DECL node for the label, if the definition is valid.
        !          2409:    Otherwise return 0.  */
        !          2410: 
        !          2411: tree
        !          2412: define_label (filename, line, name)
        !          2413:      char *filename;
        !          2414:      int line;
        !          2415:      tree name;
        !          2416: {
        !          2417:   tree decl = lookup_label (name);
        !          2418: 
        !          2419:   /* If label with this name is known from an outer context, shadow it.  */
        !          2420:   if (decl != 0 && DECL_CONTEXT (decl) != current_function_decl)
        !          2421:     {
        !          2422:       shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
        !          2423:       IDENTIFIER_LABEL_VALUE (name) = 0;
        !          2424:       decl = lookup_label (name);
        !          2425:     }
        !          2426: 
        !          2427:   if (DECL_INITIAL (decl) != 0)
        !          2428:     {
        !          2429:       error ("duplicate label `%s'", IDENTIFIER_POINTER (name));
        !          2430:       return 0;
        !          2431:     }
        !          2432:   else
        !          2433:     {
        !          2434:       /* Mark label as having been defined.  */
        !          2435:       DECL_INITIAL (decl) = error_mark_node;
        !          2436:       /* Say where in the source.  */
        !          2437:       DECL_SOURCE_FILE (decl) = filename;
        !          2438:       DECL_SOURCE_LINE (decl) = line;
        !          2439:       return decl;
        !          2440:     }
        !          2441: }
        !          2442: 
        !          2443: /* Return the list of declarations of the current level.
        !          2444:    Note that this list is in reverse order unless/until
        !          2445:    you nreverse it; and when you do nreverse it, you must
        !          2446:    store the result back using `storedecls' or you will lose.  */
        !          2447: 
        !          2448: tree
        !          2449: getdecls ()
        !          2450: {
        !          2451:   return current_binding_level->names;
        !          2452: }
        !          2453: 
        !          2454: /* Return the list of type-tags (for structs, etc) of the current level.  */
        !          2455: 
        !          2456: tree
        !          2457: gettags ()
        !          2458: {
        !          2459:   return current_binding_level->tags;
        !          2460: }
        !          2461: 
        !          2462: /* Store the list of declarations of the current level.
        !          2463:    This is done for the parameter declarations of a function being defined,
        !          2464:    after they are modified in the light of any missing parameters.  */
        !          2465: 
        !          2466: static void
        !          2467: storedecls (decls)
        !          2468:      tree decls;
        !          2469: {
        !          2470:   current_binding_level->names = decls;
        !          2471: }
        !          2472: 
        !          2473: /* Similarly, store the list of tags of the current level.  */
        !          2474: 
        !          2475: static void
        !          2476: storetags (tags)
        !          2477:      tree tags;
        !          2478: {
        !          2479:   current_binding_level->tags = tags;
        !          2480: }
        !          2481: 
        !          2482: /* Given NAME, an IDENTIFIER_NODE,
        !          2483:    return the structure (or union or enum) definition for that name.
        !          2484:    Searches binding levels from BINDING_LEVEL up to the global level.
        !          2485:    If THISLEVEL_ONLY is nonzero, searches only the specified context
        !          2486:    (but skips any tag-transparent contexts to find one that is
        !          2487:    meaningful for tags).
        !          2488:    CODE says which kind of type the caller wants;
        !          2489:    it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
        !          2490:    If the wrong kind of type is found, an error is reported.  */
        !          2491: 
        !          2492: static tree
        !          2493: lookup_tag (code, name, binding_level, thislevel_only)
        !          2494:      enum tree_code code;
        !          2495:      struct binding_level *binding_level;
        !          2496:      tree name;
        !          2497:      int thislevel_only;
        !          2498: {
        !          2499:   register struct binding_level *level;
        !          2500: 
        !          2501:   for (level = binding_level; level; level = level->level_chain)
        !          2502:     {
        !          2503:       register tree tail;
        !          2504:       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
        !          2505:        {
        !          2506:          if (TREE_PURPOSE (tail) == name)
        !          2507:            {
        !          2508:              if (TREE_CODE (TREE_VALUE (tail)) != code)
        !          2509:                {
        !          2510:                  /* Definition isn't the kind we were looking for.  */
        !          2511:                  pending_invalid_xref = name;
        !          2512:                  pending_invalid_xref_file = input_filename;
        !          2513:                  pending_invalid_xref_line = lineno;
        !          2514:                }
        !          2515:              return TREE_VALUE (tail);
        !          2516:            }
        !          2517:        }
        !          2518:       if (thislevel_only && ! level->tag_transparent)
        !          2519:        return NULL_TREE;
        !          2520:     }
        !          2521:   return NULL_TREE;
        !          2522: }
        !          2523: 
        !          2524: /* Print an error message now
        !          2525:    for a recent invalid struct, union or enum cross reference.
        !          2526:    We don't print them immediately because they are not invalid
        !          2527:    when used in the `struct foo;' construct for shadowing.  */
        !          2528: 
        !          2529: void
        !          2530: pending_xref_error ()
        !          2531: {
        !          2532:   if (pending_invalid_xref != 0)
        !          2533:     error_with_file_and_line (pending_invalid_xref_file,
        !          2534:                              pending_invalid_xref_line,
        !          2535:                              "`%s' defined as wrong kind of tag",
        !          2536:                              IDENTIFIER_POINTER (pending_invalid_xref));
        !          2537:   pending_invalid_xref = 0;
        !          2538: }
        !          2539: 
        !          2540: /* Given a type, find the tag that was defined for it and return the tag name.
        !          2541:    Otherwise return 0.  */
        !          2542: 
        !          2543: static tree
        !          2544: lookup_tag_reverse (type)
        !          2545:      tree type;
        !          2546: {
        !          2547:   register struct binding_level *level;
        !          2548: 
        !          2549:   for (level = current_binding_level; level; level = level->level_chain)
        !          2550:     {
        !          2551:       register tree tail;
        !          2552:       for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
        !          2553:        {
        !          2554:          if (TREE_VALUE (tail) == type)
        !          2555:            return TREE_PURPOSE (tail);
        !          2556:        }
        !          2557:     }
        !          2558:   return NULL_TREE;
        !          2559: }
        !          2560: 
        !          2561: /* Look up NAME in the current binding level and its superiors
        !          2562:    in the namespace of variables, functions and typedefs.
        !          2563:    Return a ..._DECL node of some kind representing its definition,
        !          2564:    or return 0 if it is undefined.  */
        !          2565: 
        !          2566: tree
        !          2567: lookup_name (name)
        !          2568:      tree name;
        !          2569: {
        !          2570:   register tree val;
        !          2571:   if (current_binding_level != global_binding_level
        !          2572:       && IDENTIFIER_LOCAL_VALUE (name))
        !          2573:     val = IDENTIFIER_LOCAL_VALUE (name);
        !          2574:   else
        !          2575:     val = IDENTIFIER_GLOBAL_VALUE (name);
        !          2576:   return val;
        !          2577: }
        !          2578: 
        !          2579: /* Similar to `lookup_name' but look only at current binding level.  */
        !          2580: 
        !          2581: tree
        !          2582: lookup_name_current_level (name)
        !          2583:      tree name;
        !          2584: {
        !          2585:   register tree t;
        !          2586: 
        !          2587:   if (current_binding_level == global_binding_level)
        !          2588:     return IDENTIFIER_GLOBAL_VALUE (name);
        !          2589: 
        !          2590:   if (IDENTIFIER_LOCAL_VALUE (name) == 0)
        !          2591:     return 0;
        !          2592: 
        !          2593:   for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
        !          2594:     if (DECL_NAME (t) == name)
        !          2595:       break;
        !          2596: 
        !          2597:   return t;
        !          2598: }
        !          2599: 
        !          2600: /* Create the predefined scalar types of C,
        !          2601:    and some nodes representing standard constants (0, 1, (void *)0).
        !          2602:    Initialize the global binding level.
        !          2603:    Make definitions for built-in primitive functions.  */
        !          2604: 
        !          2605: void
        !          2606: init_decl_processing ()
        !          2607: {
        !          2608:   register tree endlink;
        !          2609:   /* Either char* or void*.  */
        !          2610:   tree traditional_ptr_type_node;
        !          2611:   /* Data types of memcpy and strlen.  */
        !          2612:   tree memcpy_ftype, strlen_ftype;
        !          2613:   tree void_ftype_any;
        !          2614:   int wchar_type_size;
        !          2615:   tree temp;
        !          2616:   tree array_domain_type;
        !          2617: 
        !          2618:   current_function_decl = NULL;
        !          2619:   named_labels = NULL;
        !          2620:   current_binding_level = NULL_BINDING_LEVEL;
        !          2621:   free_binding_level = NULL_BINDING_LEVEL;
        !          2622:   pushlevel (0);       /* make the binding_level structure for global names */
        !          2623:   global_binding_level = current_binding_level;
        !          2624: 
        !          2625:   /* Define `int' and `char' first so that dbx will output them first.  */
        !          2626: 
        !          2627:   integer_type_node = make_signed_type (INT_TYPE_SIZE);
        !          2628:   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
        !          2629:                        integer_type_node));
        !          2630: 
        !          2631:   /* Define `char', which is like either `signed char' or `unsigned char'
        !          2632:      but not the same as either.  */
        !          2633: 
        !          2634:   char_type_node
        !          2635:     = (flag_signed_char
        !          2636:        ? make_signed_type (CHAR_TYPE_SIZE)
        !          2637:        : make_unsigned_type (CHAR_TYPE_SIZE));
        !          2638:   pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
        !          2639:                        char_type_node));
        !          2640: 
        !          2641:   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
        !          2642:   pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
        !          2643:                        long_integer_type_node));
        !          2644: 
        !          2645:   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
        !          2646:   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
        !          2647:                        unsigned_type_node));
        !          2648: 
        !          2649:   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
        !          2650:   pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
        !          2651:                        long_unsigned_type_node));
        !          2652: 
        !          2653:   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
        !          2654:   pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),
        !          2655:                        long_long_integer_type_node));
        !          2656: 
        !          2657:   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
        !          2658:   pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),
        !          2659:                        long_long_unsigned_type_node));
        !          2660: 
        !          2661:   /* `unsigned long' is the standard type for sizeof.
        !          2662:      Traditionally, use a signed type.
        !          2663:      Note that stddef.h uses `unsigned long',
        !          2664:      and this must agree, even of long and int are the same size.  */
        !          2665:   sizetype
        !          2666:     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
        !          2667:   if (flag_traditional && TREE_UNSIGNED (sizetype))
        !          2668:     sizetype = signed_type (sizetype);
        !          2669: 
        !          2670:   ptrdiff_type_node
        !          2671:     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
        !          2672: 
        !          2673:   TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
        !          2674:   TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
        !          2675:   TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
        !          2676:   TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
        !          2677:   TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
        !          2678:   TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;
        !          2679:   TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;
        !          2680: 
        !          2681:   error_mark_node = make_node (ERROR_MARK);
        !          2682:   TREE_TYPE (error_mark_node) = error_mark_node;
        !          2683: 
        !          2684:   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
        !          2685:   pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
        !          2686:                        short_integer_type_node));
        !          2687: 
        !          2688:   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
        !          2689:   pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
        !          2690:                        short_unsigned_type_node));
        !          2691: 
        !          2692:   /* Define both `signed char' and `unsigned char'.  */
        !          2693:   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
        !          2694:   pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
        !          2695:                        signed_char_type_node));
        !          2696: 
        !          2697:   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
        !          2698:   pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
        !          2699:                        unsigned_char_type_node));
        !          2700: 
        !          2701:   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
        !          2702:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
        !          2703: 
        !          2704:   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
        !          2705:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
        !          2706: 
        !          2707:   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
        !          2708:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
        !          2709: 
        !          2710:   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
        !          2711:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
        !          2712: 
        !          2713:   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
        !          2714:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
        !          2715: 
        !          2716:   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
        !          2717:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
        !          2718: 
        !          2719:   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
        !          2720:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
        !          2721: 
        !          2722:   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
        !          2723:   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
        !          2724: 
        !          2725:   float_type_node = make_node (REAL_TYPE);
        !          2726:   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
        !          2727:   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
        !          2728:                        float_type_node));
        !          2729:   layout_type (float_type_node);
        !          2730: 
        !          2731:   double_type_node = make_node (REAL_TYPE);
        !          2732:   if (flag_short_double)
        !          2733:     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
        !          2734:   else
        !          2735:     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
        !          2736:   pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
        !          2737:                        double_type_node));
        !          2738:   layout_type (double_type_node);
        !          2739: 
        !          2740:   long_double_type_node = make_node (REAL_TYPE);
        !          2741:   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
        !          2742:   pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
        !          2743:                        long_double_type_node));
        !          2744:   layout_type (long_double_type_node);
        !          2745: 
        !          2746:   complex_integer_type_node = make_node (COMPLEX_TYPE);
        !          2747:   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
        !          2748:                        complex_integer_type_node));
        !          2749:   TREE_TYPE (complex_integer_type_node) = integer_type_node;
        !          2750:   layout_type (complex_integer_type_node);
        !          2751: 
        !          2752:   complex_float_type_node = make_node (COMPLEX_TYPE);
        !          2753:   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
        !          2754:                        complex_float_type_node));
        !          2755:   TREE_TYPE (complex_float_type_node) = float_type_node;
        !          2756:   layout_type (complex_float_type_node);
        !          2757: 
        !          2758:   complex_double_type_node = make_node (COMPLEX_TYPE);
        !          2759:   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
        !          2760:                        complex_double_type_node));
        !          2761:   TREE_TYPE (complex_double_type_node) = double_type_node;
        !          2762:   layout_type (complex_double_type_node);
        !          2763: 
        !          2764:   complex_long_double_type_node = make_node (COMPLEX_TYPE);
        !          2765:   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
        !          2766:                        complex_long_double_type_node));
        !          2767:   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
        !          2768:   layout_type (complex_long_double_type_node);
        !          2769: 
        !          2770:   wchar_type_node
        !          2771:     = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
        !          2772:   wchar_type_size = TYPE_PRECISION (wchar_type_node);
        !          2773:   signed_wchar_type_node = signed_type (wchar_type_node);
        !          2774:   unsigned_wchar_type_node = unsigned_type (wchar_type_node);
        !          2775: 
        !          2776:   integer_zero_node = build_int_2 (0, 0);
        !          2777:   TREE_TYPE (integer_zero_node) = integer_type_node;
        !          2778:   integer_one_node = build_int_2 (1, 0);
        !          2779:   TREE_TYPE (integer_one_node) = integer_type_node;
        !          2780: 
        !          2781:   size_zero_node = build_int_2 (0, 0);
        !          2782:   TREE_TYPE (size_zero_node) = sizetype;
        !          2783:   size_one_node = build_int_2 (1, 0);
        !          2784:   TREE_TYPE (size_one_node) = sizetype;
        !          2785: 
        !          2786:   void_type_node = make_node (VOID_TYPE);
        !          2787:   pushdecl (build_decl (TYPE_DECL,
        !          2788:                        ridpointers[(int) RID_VOID], void_type_node));
        !          2789:   layout_type (void_type_node);        /* Uses integer_zero_node */
        !          2790:   /* We are not going to have real types in C with less than byte alignment,
        !          2791:      so we might as well not have any types that claim to have it.  */
        !          2792:   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
        !          2793: 
        !          2794:   null_pointer_node = build_int_2 (0, 0);
        !          2795:   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
        !          2796:   layout_type (TREE_TYPE (null_pointer_node));
        !          2797: 
        !          2798:   string_type_node = build_pointer_type (char_type_node);
        !          2799:   const_string_type_node
        !          2800:     = build_pointer_type (build_type_variant (char_type_node, 1, 0));
        !          2801: 
        !          2802:   /* Make a type to be the domain of a few array types
        !          2803:      whose domains don't really matter.
        !          2804:      200 is small enough that it always fits in size_t
        !          2805:      and large enough that it can hold most function names for the
        !          2806:      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
        !          2807:   array_domain_type = build_index_type (build_int_2 (200, 0));
        !          2808: 
        !          2809:   /* make a type for arrays of characters.
        !          2810:      With luck nothing will ever really depend on the length of this
        !          2811:      array type.  */
        !          2812:   char_array_type_node
        !          2813:     = build_array_type (char_type_node, array_domain_type);
        !          2814:   /* Likewise for arrays of ints.  */
        !          2815:   int_array_type_node
        !          2816:     = build_array_type (integer_type_node, array_domain_type);
        !          2817:   /* This is for wide string constants.  */
        !          2818:   wchar_array_type_node
        !          2819:     = build_array_type (wchar_type_node, array_domain_type);
        !          2820: 
        !          2821:   default_function_type
        !          2822:     = build_function_type (integer_type_node, NULL_TREE);
        !          2823: 
        !          2824:   ptr_type_node = build_pointer_type (void_type_node);
        !          2825:   const_ptr_type_node
        !          2826:     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
        !          2827: 
        !          2828:   endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
        !          2829: 
        !          2830:   void_ftype_any
        !          2831:     = build_function_type (void_type_node, NULL_TREE);
        !          2832: 
        !          2833:   double_ftype_double
        !          2834:     = build_function_type (double_type_node,
        !          2835:                           tree_cons (NULL_TREE, double_type_node, endlink));
        !          2836: 
        !          2837:   double_ftype_double_double
        !          2838:     = build_function_type (double_type_node,
        !          2839:                           tree_cons (NULL_TREE, double_type_node,
        !          2840:                                      tree_cons (NULL_TREE,
        !          2841:                                                 double_type_node, endlink)));
        !          2842: 
        !          2843:   int_ftype_int
        !          2844:     = build_function_type (integer_type_node,
        !          2845:                           tree_cons (NULL_TREE, integer_type_node, endlink));
        !          2846: 
        !          2847:   long_ftype_long
        !          2848:     = build_function_type (long_integer_type_node,
        !          2849:                           tree_cons (NULL_TREE,
        !          2850:                                      long_integer_type_node, endlink));
        !          2851: 
        !          2852:   void_ftype_ptr_ptr_int
        !          2853:     = build_function_type (void_type_node,
        !          2854:                           tree_cons (NULL_TREE, ptr_type_node,
        !          2855:                                      tree_cons (NULL_TREE, ptr_type_node,
        !          2856:                                                 tree_cons (NULL_TREE,
        !          2857:                                                            integer_type_node,
        !          2858:                                                            endlink))));
        !          2859: 
        !          2860:   int_ftype_cptr_cptr_sizet
        !          2861:     = build_function_type (integer_type_node,
        !          2862:                           tree_cons (NULL_TREE, const_ptr_type_node,
        !          2863:                                      tree_cons (NULL_TREE, const_ptr_type_node,
        !          2864:                                                 tree_cons (NULL_TREE,
        !          2865:                                                            sizetype,
        !          2866:                                                            endlink))));
        !          2867: 
        !          2868:   void_ftype_ptr_int_int
        !          2869:     = build_function_type (void_type_node,
        !          2870:                           tree_cons (NULL_TREE, ptr_type_node,
        !          2871:                                      tree_cons (NULL_TREE, integer_type_node,
        !          2872:                                                 tree_cons (NULL_TREE,
        !          2873:                                                            integer_type_node,
        !          2874:                                                            endlink))));
        !          2875: 
        !          2876:   string_ftype_ptr_ptr         /* strcpy prototype */
        !          2877:     = build_function_type (string_type_node,
        !          2878:                           tree_cons (NULL_TREE, string_type_node,
        !          2879:                                      tree_cons (NULL_TREE,
        !          2880:                                                 const_string_type_node,
        !          2881:                                                 endlink)));
        !          2882: 
        !          2883:   int_ftype_string_string      /* strcmp prototype */
        !          2884:     = build_function_type (integer_type_node,
        !          2885:                           tree_cons (NULL_TREE, const_string_type_node,
        !          2886:                                      tree_cons (NULL_TREE,
        !          2887:                                                 const_string_type_node,
        !          2888:                                                 endlink)));
        !          2889: 
        !          2890:   strlen_ftype         /* strlen prototype */
        !          2891:     = build_function_type (flag_traditional ? integer_type_node : sizetype,
        !          2892:                           tree_cons (NULL_TREE, const_string_type_node,
        !          2893:                                      endlink));
        !          2894: 
        !          2895:   traditional_ptr_type_node
        !          2896:     = (flag_traditional ? string_type_node : ptr_type_node);
        !          2897: 
        !          2898:   memcpy_ftype /* memcpy prototype */
        !          2899:     = build_function_type (traditional_ptr_type_node,
        !          2900:                           tree_cons (NULL_TREE, ptr_type_node,
        !          2901:                                      tree_cons (NULL_TREE, const_ptr_type_node,
        !          2902:                                                 tree_cons (NULL_TREE,
        !          2903:                                                            sizetype,
        !          2904:                                                            endlink))));
        !          2905: 
        !          2906:   builtin_function ("__builtin_constant_p", int_ftype_int,
        !          2907:                    BUILT_IN_CONSTANT_P, NULL_PTR);
        !          2908: 
        !          2909:   builtin_function ("__builtin_return_address",
        !          2910:                    build_function_type (ptr_type_node, 
        !          2911:                                         tree_cons (NULL_TREE,
        !          2912:                                                    unsigned_type_node,
        !          2913:                                                    endlink)),
        !          2914:                    BUILT_IN_RETURN_ADDRESS, NULL_PTR);
        !          2915: 
        !          2916:   builtin_function ("__builtin_frame_address",
        !          2917:                    build_function_type (ptr_type_node, 
        !          2918:                                         tree_cons (NULL_TREE,
        !          2919:                                                    unsigned_type_node,
        !          2920:                                                    endlink)),
        !          2921:                    BUILT_IN_FRAME_ADDRESS, NULL_PTR);
        !          2922: 
        !          2923:   builtin_function ("__builtin_alloca",
        !          2924:                    build_function_type (ptr_type_node,
        !          2925:                                         tree_cons (NULL_TREE,
        !          2926:                                                    sizetype,
        !          2927:                                                    endlink)),
        !          2928:                    BUILT_IN_ALLOCA, "alloca");
        !          2929:   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
        !          2930:   /* Define alloca, ffs as builtins.
        !          2931:      Declare _exit just to mark it as volatile.  */
        !          2932:   if (! flag_no_builtin && !flag_no_nonansi_builtin)
        !          2933:     {
        !          2934:       temp = builtin_function ("alloca",
        !          2935:                               build_function_type (ptr_type_node,
        !          2936:                                                    tree_cons (NULL_TREE,
        !          2937:                                                               sizetype,
        !          2938:                                                               endlink)),
        !          2939:                               BUILT_IN_ALLOCA, NULL_PTR);
        !          2940:       /* Suppress error if redefined as a non-function.  */
        !          2941:       DECL_BUILT_IN_NONANSI (temp) = 1;
        !          2942:       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
        !          2943:       /* Suppress error if redefined as a non-function.  */
        !          2944:       DECL_BUILT_IN_NONANSI (temp) = 1;
        !          2945:       temp = builtin_function ("_exit", void_ftype_any, NOT_BUILT_IN,
        !          2946:                               NULL_PTR);
        !          2947:       TREE_THIS_VOLATILE (temp) = 1;
        !          2948:       TREE_SIDE_EFFECTS (temp) = 1;
        !          2949:       /* Suppress error if redefined as a non-function.  */
        !          2950:       DECL_BUILT_IN_NONANSI (temp) = 1;
        !          2951:     }
        !          2952: 
        !          2953:   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
        !          2954:   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
        !          2955:                    NULL_PTR);
        !          2956:   builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
        !          2957:                    NULL_PTR);
        !          2958:   builtin_function ("__builtin_saveregs",
        !          2959:                    build_function_type (ptr_type_node, NULL_TREE),
        !          2960:                    BUILT_IN_SAVEREGS, NULL_PTR);
        !          2961: /* EXPAND_BUILTIN_VARARGS is obsolete.  */
        !          2962: #if 0
        !          2963:   builtin_function ("__builtin_varargs",
        !          2964:                    build_function_type (ptr_type_node,
        !          2965:                                         tree_cons (NULL_TREE,
        !          2966:                                                    integer_type_node,
        !          2967:                                                    endlink)),
        !          2968:                    BUILT_IN_VARARGS, NULL_PTR);
        !          2969: #endif
        !          2970:   builtin_function ("__builtin_classify_type", default_function_type,
        !          2971:                    BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
        !          2972:   builtin_function ("__builtin_next_arg",
        !          2973:                    build_function_type (ptr_type_node, endlink),
        !          2974:                    BUILT_IN_NEXT_ARG, NULL_PTR);
        !          2975:   builtin_function ("__builtin_args_info",
        !          2976:                    build_function_type (integer_type_node,
        !          2977:                                         tree_cons (NULL_TREE,
        !          2978:                                                    integer_type_node,
        !          2979:                                                    endlink)),
        !          2980:                    BUILT_IN_ARGS_INFO, NULL_PTR);
        !          2981: 
        !          2982:   /* Untyped call and return.  */
        !          2983:   builtin_function ("__builtin_apply_args",
        !          2984:                    build_function_type (ptr_type_node, NULL_TREE),
        !          2985:                    BUILT_IN_APPLY_ARGS, NULL_PTR);
        !          2986: 
        !          2987:   temp = tree_cons (NULL_TREE,
        !          2988:                    build_pointer_type (build_function_type (void_type_node,
        !          2989:                                                             NULL_TREE)),
        !          2990:                    tree_cons (NULL_TREE,
        !          2991:                               ptr_type_node,
        !          2992:                               tree_cons (NULL_TREE,
        !          2993:                                          sizetype,
        !          2994:                                          endlink)));
        !          2995:   builtin_function ("__builtin_apply",
        !          2996:                    build_function_type (ptr_type_node, temp),
        !          2997:                    BUILT_IN_APPLY, NULL_PTR);
        !          2998:   builtin_function ("__builtin_return",
        !          2999:                    build_function_type (void_type_node,
        !          3000:                                         tree_cons (NULL_TREE,
        !          3001:                                                    ptr_type_node,
        !          3002:                                                    endlink)),
        !          3003:                    BUILT_IN_RETURN, NULL_PTR);
        !          3004: 
        !          3005:   /* Currently under experimentation.  */
        !          3006:   builtin_function ("__builtin_memcpy", memcpy_ftype,
        !          3007:                    BUILT_IN_MEMCPY, "memcpy");
        !          3008:   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
        !          3009:                    BUILT_IN_MEMCMP, "memcmp");
        !          3010:   builtin_function ("__builtin_strcmp", int_ftype_string_string,
        !          3011:                    BUILT_IN_STRCMP, "strcmp");
        !          3012:   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
        !          3013:                    BUILT_IN_STRCPY, "strcpy");
        !          3014:   builtin_function ("__builtin_strlen", strlen_ftype,
        !          3015:                    BUILT_IN_STRLEN, "strlen");
        !          3016:   builtin_function ("__builtin_fsqrt", double_ftype_double, 
        !          3017:                    BUILT_IN_FSQRT, "sqrt");
        !          3018:   builtin_function ("__builtin_sin", double_ftype_double, 
        !          3019:                    BUILT_IN_SIN, "sin");
        !          3020:   builtin_function ("__builtin_cos", double_ftype_double, 
        !          3021:                    BUILT_IN_COS, "cos");
        !          3022: 
        !          3023:   /* In an ANSI C program, it is okay to supply built-in meanings
        !          3024:      for these functions, since applications cannot validly use them
        !          3025:      with any other meaning.
        !          3026:      However, honor the -fno-builtin option.  */
        !          3027:   if (!flag_no_builtin)
        !          3028:     {
        !          3029:       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
        !          3030:       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
        !          3031:       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
        !          3032:       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
        !          3033:       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
        !          3034:                        NULL_PTR);
        !          3035:       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
        !          3036:                        NULL_PTR);
        !          3037:       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
        !          3038:                        NULL_PTR);
        !          3039:       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
        !          3040:       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
        !          3041:       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
        !          3042:       builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
        !          3043: 
        !          3044:       /* Declare these functions volatile
        !          3045:         to avoid spurious "control drops through" warnings.  */
        !          3046:       /* Don't specify the argument types, to avoid errors
        !          3047:         from certain code which isn't valid in ANSI but which exists.  */
        !          3048:       temp = builtin_function ("abort", void_ftype_any, NOT_BUILT_IN,
        !          3049:                               NULL_PTR);
        !          3050:       TREE_THIS_VOLATILE (temp) = 1;
        !          3051:       TREE_SIDE_EFFECTS (temp) = 1;
        !          3052:       temp = builtin_function ("exit", void_ftype_any, NOT_BUILT_IN, NULL_PTR);
        !          3053:       TREE_THIS_VOLATILE (temp) = 1;
        !          3054:       TREE_SIDE_EFFECTS (temp) = 1;
        !          3055:     }
        !          3056: 
        !          3057: #if 0
        !          3058:   /* Support for these has not been written in either expand_builtin
        !          3059:      or build_function_call.  */
        !          3060:   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
        !          3061:   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
        !          3062:   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
        !          3063:                    NULL_PTR);
        !          3064:   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
        !          3065:                    NULL_PTR);
        !          3066:   builtin_function ("__builtin_fmod", double_ftype_double_double,
        !          3067:                    BUILT_IN_FMOD, NULL_PTR);
        !          3068:   builtin_function ("__builtin_frem", double_ftype_double_double,
        !          3069:                    BUILT_IN_FREM, NULL_PTR);
        !          3070:   builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
        !          3071:                    BUILT_IN_MEMSET, NULL_PTR);
        !          3072:   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
        !          3073:                    NULL_PTR);
        !          3074:   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
        !          3075:                    NULL_PTR);
        !          3076: #endif
        !          3077: 
        !          3078:   /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
        !          3079:   declare_function_name ();
        !          3080: 
        !          3081:   start_identifier_warnings ();
        !          3082: 
        !          3083:   /* Prepare to check format strings against argument lists.  */
        !          3084:   init_function_format_info ();
        !          3085: 
        !          3086:   init_iterators ();
        !          3087: 
        !          3088:   incomplete_decl_finalize_hook = finish_incomplete_decl;
        !          3089: }
        !          3090: 
        !          3091: /* Return a definition for a builtin function named NAME and whose data type
        !          3092:    is TYPE.  TYPE should be a function type with argument types.
        !          3093:    FUNCTION_CODE tells later passes how to compile calls to this function.
        !          3094:    See tree.h for its possible values.
        !          3095: 
        !          3096:    If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
        !          3097:    the name to be called if we can't opencode the function.  */
        !          3098: 
        !          3099: tree
        !          3100: builtin_function (name, type, function_code, library_name)
        !          3101:      char *name;
        !          3102:      tree type;
        !          3103:      enum built_in_function function_code;
        !          3104:      char *library_name;
        !          3105: {
        !          3106:   tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
        !          3107:   DECL_EXTERNAL (decl) = 1;
        !          3108:   TREE_PUBLIC (decl) = 1;
        !          3109:   /* If -traditional, permit redefining a builtin function any way you like.
        !          3110:      (Though really, if the program redefines these functions,
        !          3111:      it probably won't work right unless compiled with -fno-builtin.)  */
        !          3112:   if (flag_traditional && name[0] != '_')
        !          3113:     DECL_BUILT_IN_NONANSI (decl) = 1;
        !          3114:   if (library_name)
        !          3115:     DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
        !          3116:   make_decl_rtl (decl, NULL_PTR, 1);
        !          3117:   pushdecl (decl);
        !          3118:   if (function_code != NOT_BUILT_IN)
        !          3119:     {
        !          3120:       DECL_BUILT_IN (decl) = 1;
        !          3121:       DECL_SET_FUNCTION_CODE (decl, function_code);
        !          3122:     }
        !          3123:   /* Warn if a function in the namespace for users
        !          3124:      is used without an occasion to consider it declared.  */
        !          3125:   if (name[0] != '_' || name[1] != '_')
        !          3126:     C_DECL_ANTICIPATED (decl) = 1;
        !          3127: 
        !          3128:   return decl;
        !          3129: }
        !          3130: 
        !          3131: /* Called when a declaration is seen that contains no names to declare.
        !          3132:    If its type is a reference to a structure, union or enum inherited
        !          3133:    from a containing scope, shadow that tag name for the current scope
        !          3134:    with a forward reference.
        !          3135:    If its type defines a new named structure or union
        !          3136:    or defines an enum, it is valid but we need not do anything here.
        !          3137:    Otherwise, it is an error.  */
        !          3138: 
        !          3139: void
        !          3140: shadow_tag (declspecs)
        !          3141:      tree declspecs;
        !          3142: {
        !          3143:   shadow_tag_warned (declspecs, 0);
        !          3144: }
        !          3145: 
        !          3146: void
        !          3147: shadow_tag_warned (declspecs, warned)
        !          3148:      tree declspecs;
        !          3149:      int warned;
        !          3150:      /* 1 => we have done a pedwarn.  2 => we have done a warning, but
        !          3151:        no pedwarn.  */
        !          3152: {
        !          3153:   int found_tag = 0;
        !          3154:   register tree link;
        !          3155: 
        !          3156:   pending_invalid_xref = 0;
        !          3157: 
        !          3158:   for (link = declspecs; link; link = TREE_CHAIN (link))
        !          3159:     {
        !          3160:       register tree value = TREE_VALUE (link);
        !          3161:       register enum tree_code code = TREE_CODE (value);
        !          3162: 
        !          3163:       if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
        !          3164:        /* Used to test also that TYPE_SIZE (value) != 0.
        !          3165:           That caused warning for `struct foo;' at top level in the file.  */
        !          3166:        {
        !          3167:          register tree name = lookup_tag_reverse (value);
        !          3168:          register tree t;
        !          3169: 
        !          3170:          found_tag++;
        !          3171: 
        !          3172:          if (name == 0)
        !          3173:            {
        !          3174:              if (warned != 1 && code != ENUMERAL_TYPE)
        !          3175:                /* Empty unnamed enum OK */
        !          3176:                {
        !          3177:                  pedwarn ("unnamed struct/union that defines no instances");
        !          3178:                  warned = 1;
        !          3179:                }
        !          3180:            }
        !          3181:          else
        !          3182:            {
        !          3183:              t = lookup_tag (code, name, current_binding_level, 1);
        !          3184: 
        !          3185:              if (t == 0)
        !          3186:                {
        !          3187:                  t = make_node (code);
        !          3188:                  pushtag (name, t);
        !          3189:                }
        !          3190:            }
        !          3191:        }
        !          3192:       else
        !          3193:        {
        !          3194:          if (!warned)
        !          3195:            {
        !          3196:              warning ("useless keyword or type name in empty declaration");
        !          3197:              warned = 2;
        !          3198:            }
        !          3199:        }
        !          3200:     }
        !          3201: 
        !          3202:   if (found_tag > 1)
        !          3203:     error ("two types specified in one empty declaration");
        !          3204: 
        !          3205:   if (warned != 1)
        !          3206:     {
        !          3207:       if (found_tag == 0)
        !          3208:        pedwarn ("empty declaration");
        !          3209:     }
        !          3210: }
        !          3211: 
        !          3212: /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
        !          3213: 
        !          3214: tree
        !          3215: groktypename (typename)
        !          3216:      tree typename;
        !          3217: {
        !          3218:   if (TREE_CODE (typename) != TREE_LIST)
        !          3219:     return typename;
        !          3220:   return grokdeclarator (TREE_VALUE (typename),
        !          3221:                         TREE_PURPOSE (typename),
        !          3222:                         TYPENAME, 0);
        !          3223: }
        !          3224: 
        !          3225: /* Return a PARM_DECL node for a given pair of specs and declarator.  */
        !          3226: 
        !          3227: tree
        !          3228: groktypename_in_parm_context (typename)
        !          3229:      tree typename;
        !          3230: {
        !          3231:   if (TREE_CODE (typename) != TREE_LIST)
        !          3232:     return typename;
        !          3233:   return grokdeclarator (TREE_VALUE (typename),
        !          3234:                         TREE_PURPOSE (typename),
        !          3235:                         PARM, 0);
        !          3236: }
        !          3237: 
        !          3238: /* Decode a declarator in an ordinary declaration or data definition.
        !          3239:    This is called as soon as the type information and variable name
        !          3240:    have been parsed, before parsing the initializer if any.
        !          3241:    Here we create the ..._DECL node, fill in its type,
        !          3242:    and put it on the list of decls for the current context.
        !          3243:    The ..._DECL node is returned as the value.
        !          3244: 
        !          3245:    Exception: for arrays where the length is not specified,
        !          3246:    the type is left null, to be filled in by `finish_decl'.
        !          3247: 
        !          3248:    Function definitions do not come here; they go to start_function
        !          3249:    instead.  However, external and forward declarations of functions
        !          3250:    do go through here.  Structure field declarations are done by
        !          3251:    grokfield and not through here.  */
        !          3252: 
        !          3253: /* Set this to zero to debug not using the temporary obstack
        !          3254:    to parse initializers.  */
        !          3255: int debug_temp_inits = 1;
        !          3256: 
        !          3257: tree
        !          3258: start_decl (declarator, declspecs, initialized)
        !          3259:      tree declarator, declspecs;
        !          3260:      int initialized;
        !          3261: {
        !          3262:   register tree decl = grokdeclarator (declarator, declspecs,
        !          3263:                                       NORMAL, initialized);
        !          3264:   register tree tem;
        !          3265:   int init_written = initialized;
        !          3266: 
        !          3267:   /* The corresponding pop_obstacks is in finish_decl.  */
        !          3268:   push_obstacks_nochange ();
        !          3269: 
        !          3270:   if (initialized)
        !          3271:     /* Is it valid for this decl to have an initializer at all?
        !          3272:        If not, set INITIALIZED to zero, which will indirectly
        !          3273:        tell `finish_decl' to ignore the initializer once it is parsed.  */
        !          3274:     switch (TREE_CODE (decl))
        !          3275:       {
        !          3276:       case TYPE_DECL:
        !          3277:        /* typedef foo = bar  means give foo the same type as bar.
        !          3278:           We haven't parsed bar yet, so `finish_decl' will fix that up.
        !          3279:           Any other case of an initialization in a TYPE_DECL is an error.  */
        !          3280:        if (pedantic || list_length (declspecs) > 1)
        !          3281:          {
        !          3282:            error ("typedef `%s' is initialized",
        !          3283:                   IDENTIFIER_POINTER (DECL_NAME (decl)));
        !          3284:            initialized = 0;
        !          3285:          }
        !          3286:        break;
        !          3287: 
        !          3288:       case FUNCTION_DECL:
        !          3289:        error ("function `%s' is initialized like a variable",
        !          3290:               IDENTIFIER_POINTER (DECL_NAME (decl)));
        !          3291:        initialized = 0;
        !          3292:        break;
        !          3293: 
        !          3294:       case PARM_DECL:
        !          3295:        /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
        !          3296:        error ("parameter `%s' is initialized",
        !          3297:               IDENTIFIER_POINTER (DECL_NAME (decl)));
        !          3298:        initialized = 0;
        !          3299:        break;
        !          3300: 
        !          3301:       default:
        !          3302:        /* Don't allow initializations for incomplete types
        !          3303:           except for arrays which might be completed by the initialization.  */
        !          3304:        if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
        !          3305:          {
        !          3306:            /* A complete type is ok if size is fixed.  */
        !          3307: 
        !          3308:            if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
        !          3309:                || C_DECL_VARIABLE_SIZE (decl))
        !          3310:              {
        !          3311:                error ("variable-sized object may not be initialized");
        !          3312:                initialized = 0;
        !          3313:              }
        !          3314:          }
        !          3315:        else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
        !          3316:          {
        !          3317:            error ("variable `%s' has initializer but incomplete type",
        !          3318:                   IDENTIFIER_POINTER (DECL_NAME (decl)));
        !          3319:            initialized = 0;
        !          3320:          }
        !          3321:        else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
        !          3322:          {
        !          3323:            error ("elements of array `%s' have incomplete type",
        !          3324:                   IDENTIFIER_POINTER (DECL_NAME (decl)));
        !          3325:            initialized = 0;
        !          3326:          }
        !          3327:       }
        !          3328: 
        !          3329:   if (initialized)
        !          3330:     {
        !          3331: #if 0  /* Seems redundant with grokdeclarator.  */
        !          3332:       if (current_binding_level != global_binding_level
        !          3333:          && DECL_EXTERNAL (decl)
        !          3334:          && TREE_CODE (decl) != FUNCTION_DECL)
        !          3335:        warning ("declaration of `%s' has `extern' and is initialized",
        !          3336:                 IDENTIFIER_POINTER (DECL_NAME (decl)));
        !          3337: #endif
        !          3338:       DECL_EXTERNAL (decl) = 0;
        !          3339:       if (current_binding_level == global_binding_level)
        !          3340:        TREE_STATIC (decl) = 1;
        !          3341: 
        !          3342:       /* Tell `pushdecl' this is an initialized decl
        !          3343:         even though we don't yet have the initializer expression.
        !          3344:         Also tell `finish_decl' it may store the real initializer.  */
        !          3345:       DECL_INITIAL (decl) = error_mark_node;
        !          3346:     }
        !          3347: 
        !          3348:   /* If this is a function declaration, write a record describing it to the
        !          3349:      prototypes file (if requested).  */
        !          3350: 
        !          3351:   if (TREE_CODE (decl) == FUNCTION_DECL)
        !          3352:     gen_aux_info_record (decl, 0, 0, TYPE_ARG_TYPES (TREE_TYPE (decl)) != 0);
        !          3353: 
        !          3354:   /* Add this decl to the current binding level.
        !          3355:      TEM may equal DECL or it may be a previous decl of the same name.  */
        !          3356:   tem = pushdecl (decl);
        !          3357: 
        !          3358:   /* For a local variable, define the RTL now.  */
        !          3359:   if (current_binding_level != global_binding_level
        !          3360:       /* But not if this is a duplicate decl
        !          3361:         and we preserved the rtl from the previous one
        !          3362:         (which may or may not happen).  */
        !          3363:       && DECL_RTL (tem) == 0)
        !          3364:     {
        !          3365:       if (TYPE_SIZE (TREE_TYPE (tem)) != 0)
        !          3366:        expand_decl (tem);
        !          3367:       else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
        !          3368:               && DECL_INITIAL (tem) != 0)
        !          3369:        expand_decl (tem);
        !          3370:     }
        !          3371: 
        !          3372:   if (init_written)
        !          3373:     {
        !          3374:       /* When parsing and digesting the initializer,
        !          3375:         use temporary storage.  Do this even if we will ignore the value.  */
        !          3376:       if (current_binding_level == global_binding_level && debug_temp_inits)
        !          3377:        temporary_allocation ();
        !          3378:     }
        !          3379: 
        !          3380:   return tem;
        !          3381: }
        !          3382: 
        !          3383: /* Finish processing of a declaration;
        !          3384:    install its initial value.
        !          3385:    If the length of an array type is not known before,
        !          3386:    it must be determined now, from the initial value, or it is an error.  */
        !          3387: 
        !          3388: void
        !          3389: finish_decl (decl, init, asmspec_tree)
        !          3390:      tree decl, init;
        !          3391:      tree asmspec_tree;
        !          3392: {
        !          3393:   register tree type = TREE_TYPE (decl);
        !          3394:   int was_incomplete = (DECL_SIZE (decl) == 0);
        !          3395:   int temporary = allocation_temporary_p ();
        !          3396:   char *asmspec = 0;
        !          3397: 
        !          3398:   if (asmspec_tree)
        !          3399:     asmspec = TREE_STRING_POINTER (asmspec_tree);
        !          3400: 
        !          3401:   /* If `start_decl' didn't like having an initialization, ignore it now.  */
        !          3402: 
        !          3403:   if (init != 0 && DECL_INITIAL (decl) == 0)
        !          3404:     init = 0;
        !          3405:   /* Don't crash if parm is initialized.  */
        !          3406:   if (TREE_CODE (decl) == PARM_DECL)
        !          3407:     init = 0;
        !          3408: 
        !          3409:   if (ITERATOR_P (decl))
        !          3410:     {
        !          3411:       if (init == 0)
        !          3412:        error_with_decl (decl, "iterator has no initial value");
        !          3413:       else
        !          3414:        init = save_expr (init);
        !          3415:     }
        !          3416: 
        !          3417:   if (init)
        !          3418:     {
        !          3419:       if (TREE_CODE (decl) != TYPE_DECL)
        !          3420:        store_init_value (decl, init);
        !          3421:       else
        !          3422:        {
        !          3423:          /* typedef foo = bar; store the type of bar as the type of foo.  */
        !          3424:          TREE_TYPE (decl) = TREE_TYPE (init);
        !          3425:          DECL_INITIAL (decl) = init = 0;
        !          3426:        }
        !          3427:     }
        !          3428: 
        !          3429:   /* Pop back to the obstack that is current for this binding level.
        !          3430:      This is because MAXINDEX, rtl, etc. to be made below
        !          3431:      must go in the permanent obstack.  But don't discard the
        !          3432:      temporary data yet.  */
        !          3433:   pop_obstacks ();
        !          3434: #if 0 /* pop_obstacks was near the end; this is what was here.  */
        !          3435:   if (current_binding_level == global_binding_level && temporary)
        !          3436:     end_temporary_allocation ();
        !          3437: #endif
        !          3438: 
        !          3439:   /* Deduce size of array from initialization, if not already known */
        !          3440: 
        !          3441:   if (TREE_CODE (type) == ARRAY_TYPE
        !          3442:       && TYPE_DOMAIN (type) == 0
        !          3443:       && TREE_CODE (decl) != TYPE_DECL)
        !          3444:     {
        !          3445:       int do_default
        !          3446:        = (TREE_STATIC (decl)
        !          3447:           /* Even if pedantic, an external linkage array
        !          3448:              may have incomplete type at first.  */
        !          3449:           ? pedantic && !TREE_PUBLIC (decl)
        !          3450:           : !DECL_EXTERNAL (decl));
        !          3451:       int failure
        !          3452:        = complete_array_type (type, DECL_INITIAL (decl), do_default);
        !          3453: 
        !          3454:       /* Get the completed type made by complete_array_type.  */
        !          3455:       type = TREE_TYPE (decl);
        !          3456: 
        !          3457:       if (failure == 1)
        !          3458:        error_with_decl (decl, "initializer fails to determine size of `%s'");
        !          3459: 
        !          3460:       if (failure == 2)
        !          3461:        {
        !          3462:          if (do_default)
        !          3463:            error_with_decl (decl, "array size missing in `%s'");
        !          3464:          /* If a `static' var's size isn't known,
        !          3465:             make it extern as well as static, so it does not get
        !          3466:             allocated.
        !          3467:             If it is not `static', then do not mark extern;
        !          3468:             finish_incomplete_decl will give it a default size
        !          3469:             and it will get allocated.  */
        !          3470:          else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
        !          3471:            DECL_EXTERNAL (decl) = 1;
        !          3472:        }
        !          3473: 
        !          3474:       if (pedantic && TYPE_DOMAIN (type) != 0
        !          3475:          && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
        !          3476:                              integer_zero_node))
        !          3477:        error_with_decl (decl, "zero-size array `%s'");
        !          3478: 
        !          3479:       layout_decl (decl, 0);
        !          3480:     }
        !          3481: 
        !          3482:   if (TREE_CODE (decl) == VAR_DECL)
        !          3483:     {
        !          3484:       if (DECL_SIZE (decl) == 0
        !          3485:          && TYPE_SIZE (TREE_TYPE (decl)) != 0)
        !          3486:        layout_decl (decl, 0);
        !          3487: 
        !          3488:       if (DECL_SIZE (decl) == 0
        !          3489:          && (TREE_STATIC (decl)
        !          3490:              ?
        !          3491:                /* A static variable with an incomplete type
        !          3492:                   is an error if it is initialized.
        !          3493:                   Also if it is not file scope.
        !          3494:                   Otherwise, let it through, but if it is not `extern'
        !          3495:                   then it may cause an error message later.  */
        !          3496:                (DECL_INITIAL (decl) != 0
        !          3497:                 || current_binding_level != global_binding_level)
        !          3498:              :
        !          3499:                /* An automatic variable with an incomplete type
        !          3500:                   is an error.  */
        !          3501:                !DECL_EXTERNAL (decl)))
        !          3502:        {
        !          3503:          error_with_decl (decl, "storage size of `%s' isn't known");
        !          3504:          TREE_TYPE (decl) = error_mark_node;
        !          3505:        }
        !          3506: 
        !          3507:       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
        !          3508:          && DECL_SIZE (decl) != 0)
        !          3509:        {
        !          3510:          if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
        !          3511:            constant_expression_warning (DECL_SIZE (decl));
        !          3512:          else
        !          3513:            error_with_decl (decl, "storage size of `%s' isn't constant");
        !          3514:        }
        !          3515:     }
        !          3516: 
        !          3517:   /* Output the assembler code and/or RTL code for variables and functions,
        !          3518:      unless the type is an undefined structure or union.
        !          3519:      If not, it will get done when the type is completed.  */
        !          3520: 
        !          3521:   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
        !          3522:     {
        !          3523:       if (flag_traditional && allocation_temporary_p ())
        !          3524:        {
        !          3525:          push_obstacks_nochange ();
        !          3526:          end_temporary_allocation ();
        !          3527:          /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
        !          3528:          maybe_objc_check_decl (decl);
        !          3529:          rest_of_decl_compilation (decl, asmspec,
        !          3530:                                    current_binding_level == global_binding_level,
        !          3531:                                    0);
        !          3532:          pop_obstacks ();
        !          3533:        }
        !          3534:       else
        !          3535:        {
        !          3536:          /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
        !          3537:          maybe_objc_check_decl (decl);
        !          3538:          rest_of_decl_compilation (decl, asmspec,
        !          3539:                                    current_binding_level == global_binding_level,
        !          3540:                                    0);
        !          3541:        }
        !          3542:       if (current_binding_level != global_binding_level)
        !          3543:        {
        !          3544:          /* Recompute the RTL of a local array now
        !          3545:             if it used to be an incomplete type.  */
        !          3546:          if (was_incomplete
        !          3547:              && ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
        !          3548:            {
        !          3549:              /* If we used it already as memory, it must stay in memory.  */
        !          3550:              TREE_ADDRESSABLE (decl) = TREE_USED (decl);
        !          3551:              /* If it's still incomplete now, no init will save it.  */
        !          3552:              if (DECL_SIZE (decl) == 0)
        !          3553:                DECL_INITIAL (decl) = 0;
        !          3554:              expand_decl (decl);
        !          3555:            }
        !          3556:          /* Compute and store the initial value.  */
        !          3557:          if (TREE_CODE (decl) != FUNCTION_DECL)
        !          3558:            expand_decl_init (decl);
        !          3559:        }
        !          3560:     }
        !          3561: 
        !          3562:   if (TREE_CODE (decl) == TYPE_DECL)
        !          3563:     {
        !          3564:       /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
        !          3565:       maybe_objc_check_decl (decl);
        !          3566:       rest_of_decl_compilation (decl, NULL_PTR,
        !          3567:                                current_binding_level == global_binding_level,
        !          3568:                                0);
        !          3569:     }
        !          3570: 
        !          3571:   /* ??? After 2.3, test (init != 0) instead of TREE_CODE.  */
        !          3572:   if (!(TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
        !          3573:       && temporary && TREE_PERMANENT (decl)
        !          3574:       /* DECL_INITIAL is not defined in PARM_DECLs, since it shares
        !          3575:         space with DECL_ARG_TYPE.  */
        !          3576:       && TREE_CODE (decl) != PARM_DECL)
        !          3577:     {
        !          3578:       /* We need to remember that this array HAD an initialization,
        !          3579:         but discard the actual temporary nodes,
        !          3580:         since we can't have a permanent node keep pointing to them.  */
        !          3581:       /* We make an exception for inline functions, since it's
        !          3582:         normal for a local extern redeclaration of an inline function
        !          3583:         to have a copy of the top-level decl's DECL_INLINE.  */
        !          3584:       if (DECL_INITIAL (decl) != 0)
        !          3585:        {
        !          3586:          /* If this is a static const variable, then preserve the
        !          3587:             initializer instead of discarding it so that we can optimize
        !          3588:             references to it.  */
        !          3589:          if (TREE_STATIC (decl) && TREE_READONLY (decl))
        !          3590:            {
        !          3591:              preserve_initializer ();
        !          3592:              /* Hack?  Set the permanent bit for something that is permanent,
        !          3593:                 but not on the permenent obstack, so as to convince
        !          3594:                 output_constant_def to make its rtl on the permanent
        !          3595:                 obstack.  */
        !          3596:              TREE_PERMANENT (DECL_INITIAL (decl)) = 1;
        !          3597:            }
        !          3598:          else
        !          3599:            DECL_INITIAL (decl) = error_mark_node;
        !          3600:        }
        !          3601:     }
        !          3602: 
        !          3603: #if 0
        !          3604:   /* Resume permanent allocation, if not within a function.  */
        !          3605:   /* The corresponding push_obstacks_nochange is in start_decl,
        !          3606:      and in push_parm_decl and in grokfield.  */
        !          3607:   pop_obstacks ();
        !          3608: #endif
        !          3609: 
        !          3610:   /* If we have gone back from temporary to permanent allocation,
        !          3611:      actually free the temporary space that we no longer need.  */
        !          3612:   if (temporary && !allocation_temporary_p ())
        !          3613:     permanent_allocation ();
        !          3614: 
        !          3615:   /* At the end of a declaration, throw away any variable type sizes
        !          3616:      of types defined inside that declaration.  There is no use
        !          3617:      computing them in the following function definition.  */
        !          3618:   if (current_binding_level == global_binding_level)
        !          3619:     get_pending_sizes ();
        !          3620: }
        !          3621: 
        !          3622: /* If DECL has a cleanup, build and return that cleanup here.
        !          3623:    This is a callback called by expand_expr.  */
        !          3624: 
        !          3625: tree
        !          3626: maybe_build_cleanup (decl)
        !          3627:      tree decl;
        !          3628: {
        !          3629:   /* There are no cleanups in C.  */
        !          3630:   return NULL_TREE;
        !          3631: }
        !          3632: 
        !          3633: /* Given a parsed parameter declaration,
        !          3634:    decode it into a PARM_DECL and push that on the current binding level.
        !          3635:    Also, for the sake of forward parm decls,
        !          3636:    record the given order of parms in `parm_order'.  */
        !          3637: 
        !          3638: void
        !          3639: push_parm_decl (parm)
        !          3640:      tree parm;
        !          3641: {
        !          3642:   tree decl, olddecl;
        !          3643:   int old_immediate_size_expand = immediate_size_expand;
        !          3644:   /* Don't try computing parm sizes now -- wait till fn is called.  */
        !          3645:   immediate_size_expand = 0;
        !          3646: 
        !          3647:   /* The corresponding pop_obstacks is in finish_decl.  */
        !          3648:   push_obstacks_nochange ();
        !          3649: 
        !          3650:   decl = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), PARM, 0);
        !          3651: 
        !          3652: #if 0
        !          3653:   if (DECL_NAME (decl))
        !          3654:     {
        !          3655:       olddecl = lookup_name (DECL_NAME (decl));
        !          3656:       if (pedantic && olddecl != 0 && TREE_CODE (olddecl) == TYPE_DECL)
        !          3657:        pedwarn_with_decl (decl, "ANSI C forbids parameter `%s' shadowing typedef");
        !          3658:     }
        !          3659: #endif
        !          3660: 
        !          3661:   decl = pushdecl (decl);
        !          3662: 
        !          3663:   immediate_size_expand = old_immediate_size_expand;
        !          3664: 
        !          3665:   current_binding_level->parm_order
        !          3666:     = tree_cons (NULL_TREE, decl, current_binding_level->parm_order);
        !          3667: 
        !          3668:   /* Add this decl to the current binding level.  */
        !          3669:   finish_decl (decl, NULL_TREE, NULL_TREE);
        !          3670: }
        !          3671: 
        !          3672: /* Clear the given order of parms in `parm_order'.
        !          3673:    Used at start of parm list,
        !          3674:    and also at semicolon terminating forward decls.  */
        !          3675: 
        !          3676: void
        !          3677: clear_parm_order ()
        !          3678: {
        !          3679:   current_binding_level->parm_order = NULL_TREE;
        !          3680: }
        !          3681: 
        !          3682: /* Make TYPE a complete type based on INITIAL_VALUE.
        !          3683:    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
        !          3684:    2 if there was no information (in which case assume 1 if DO_DEFAULT).  */
        !          3685: 
        !          3686: int
        !          3687: complete_array_type (type, initial_value, do_default)
        !          3688:      tree type;
        !          3689:      tree initial_value;
        !          3690:      int do_default;
        !          3691: {
        !          3692:   register tree maxindex = NULL_TREE;
        !          3693:   int value = 0;
        !          3694: 
        !          3695:   if (initial_value)
        !          3696:     {
        !          3697:       /* Note MAXINDEX  is really the maximum index,
        !          3698:         one less than the size.  */
        !          3699:       if (TREE_CODE (initial_value) == STRING_CST)
        !          3700:        {
        !          3701:          int eltsize
        !          3702:            = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
        !          3703:          maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
        !          3704:                                   / eltsize) - 1, 0);
        !          3705:        }
        !          3706:       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
        !          3707:        {
        !          3708:          tree elts = CONSTRUCTOR_ELTS (initial_value);
        !          3709:          maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
        !          3710:          for (; elts; elts = TREE_CHAIN (elts))
        !          3711:            {
        !          3712:              if (TREE_PURPOSE (elts))
        !          3713:                maxindex = TREE_PURPOSE (elts);
        !          3714:              else
        !          3715:                maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
        !          3716:            }
        !          3717:          maxindex = copy_node (maxindex);
        !          3718:        }
        !          3719:       else
        !          3720:        {
        !          3721:          /* Make an error message unless that happened already.  */
        !          3722:          if (initial_value != error_mark_node)
        !          3723:            value = 1;
        !          3724: 
        !          3725:          /* Prevent further error messages.  */
        !          3726:          maxindex = build_int_2 (0, 0);
        !          3727:        }
        !          3728:     }
        !          3729: 
        !          3730:   if (!maxindex)
        !          3731:     {
        !          3732:       if (do_default)
        !          3733:        maxindex = build_int_2 (0, 0);
        !          3734:       value = 2;
        !          3735:     }
        !          3736: 
        !          3737:   if (maxindex)
        !          3738:     {
        !          3739:       TYPE_DOMAIN (type) = build_index_type (maxindex);
        !          3740:       if (!TREE_TYPE (maxindex))
        !          3741:        TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
        !          3742: #if 0 /* I took out this change
        !          3743:         together with the change in build_array_type. --rms  */
        !          3744:       change_main_variant (type,
        !          3745:                           build_array_type (TREE_TYPE (type),
        !          3746:                                             TYPE_DOMAIN (type)));
        !          3747: #endif
        !          3748:     }
        !          3749: 
        !          3750:   /* Lay out the type now that we can get the real answer.  */
        !          3751: 
        !          3752:   layout_type (type);
        !          3753: 
        !          3754:   return value;
        !          3755: }
        !          3756: 
        !          3757: /* Given declspecs and a declarator,
        !          3758:    determine the name and type of the object declared
        !          3759:    and construct a ..._DECL node for it.
        !          3760:    (In one case we can return a ..._TYPE node instead.
        !          3761:     For invalid input we sometimes return 0.)
        !          3762: 
        !          3763:    DECLSPECS is a chain of tree_list nodes whose value fields
        !          3764:     are the storage classes and type specifiers.
        !          3765: 
        !          3766:    DECL_CONTEXT says which syntactic context this declaration is in:
        !          3767:      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
        !          3768:      FUNCDEF for a function definition.  Like NORMAL but a few different
        !          3769:       error messages in each case.  Return value may be zero meaning
        !          3770:       this definition is too screwy to try to parse.
        !          3771:      PARM for a parameter declaration (either within a function prototype
        !          3772:       or before a function body).  Make a PARM_DECL, or return void_type_node.
        !          3773:      TYPENAME if for a typename (in a cast or sizeof).
        !          3774:       Don't make a DECL node; just return the ..._TYPE node.
        !          3775:      FIELD for a struct or union field; make a FIELD_DECL.
        !          3776:      BITFIELD for a field with specified width.
        !          3777:    INITIALIZED is 1 if the decl has an initializer.
        !          3778: 
        !          3779:    In the TYPENAME case, DECLARATOR is really an absolute declarator.
        !          3780:    It may also be so in the PARM case, for a prototype where the
        !          3781:    argument type is specified but not the name.
        !          3782: 
        !          3783:    This function is where the complicated C meanings of `static'
        !          3784:    and `extern' are interpreted.  */
        !          3785: 
        !          3786: static tree
        !          3787: grokdeclarator (declarator, declspecs, decl_context, initialized)
        !          3788:      tree declspecs;
        !          3789:      tree declarator;
        !          3790:      enum decl_context decl_context;
        !          3791:      int initialized;
        !          3792: {
        !          3793:   int specbits = 0;
        !          3794:   tree spec;
        !          3795:   tree type = NULL_TREE;
        !          3796:   int longlong = 0;
        !          3797:   int constp;
        !          3798:   int volatilep;
        !          3799:   int inlinep;
        !          3800:   int explicit_int = 0;
        !          3801:   int explicit_char = 0;
        !          3802:   int defaulted_int = 0;
        !          3803:   tree typedef_decl = 0;
        !          3804:   char *name;
        !          3805:   tree typedef_type = 0;
        !          3806:   int funcdef_flag = 0;
        !          3807:   enum tree_code innermost_code = ERROR_MARK;
        !          3808:   int bitfield = 0;
        !          3809:   int size_varies = 0;
        !          3810: 
        !          3811:   if (decl_context == BITFIELD)
        !          3812:     bitfield = 1, decl_context = FIELD;
        !          3813: 
        !          3814:   if (decl_context == FUNCDEF)
        !          3815:     funcdef_flag = 1, decl_context = NORMAL;
        !          3816: 
        !          3817:   push_obstacks_nochange ();
        !          3818: 
        !          3819:   if (flag_traditional && allocation_temporary_p ())
        !          3820:     end_temporary_allocation ();
        !          3821: 
        !          3822:   /* Look inside a declarator for the name being declared
        !          3823:      and get it as a string, for an error message.  */
        !          3824:   {
        !          3825:     register tree decl = declarator;
        !          3826:     name = 0;
        !          3827: 
        !          3828:     while (decl)
        !          3829:       switch (TREE_CODE (decl))
        !          3830:        {
        !          3831:        case ARRAY_REF:
        !          3832:        case INDIRECT_REF:
        !          3833:        case CALL_EXPR:
        !          3834:          innermost_code = TREE_CODE (decl);
        !          3835:          decl = TREE_OPERAND (decl, 0);
        !          3836:          break;
        !          3837: 
        !          3838:        case IDENTIFIER_NODE:
        !          3839:          name = IDENTIFIER_POINTER (decl);
        !          3840:          decl = 0;
        !          3841:          break;
        !          3842: 
        !          3843:        default:
        !          3844:          abort ();
        !          3845:        }
        !          3846:     if (name == 0)
        !          3847:       name = "type name";
        !          3848:   }
        !          3849: 
        !          3850:   /* A function definition's declarator must have the form of
        !          3851:      a function declarator.  */
        !          3852: 
        !          3853:   if (funcdef_flag && innermost_code != CALL_EXPR)
        !          3854:     return 0;
        !          3855: 
        !          3856:   /* Anything declared one level down from the top level
        !          3857:      must be one of the parameters of a function
        !          3858:      (because the body is at least two levels down).  */
        !          3859: 
        !          3860:   /* If this looks like a function definition, make it one,
        !          3861:      even if it occurs where parms are expected.
        !          3862:      Then store_parm_decls will reject it and not use it as a parm.  */
        !          3863:   if (decl_context == NORMAL && !funcdef_flag
        !          3864:       && current_binding_level->level_chain == global_binding_level)
        !          3865:     decl_context = PARM;
        !          3866: 
        !          3867:   /* Look through the decl specs and record which ones appear.
        !          3868:      Some typespecs are defined as built-in typenames.
        !          3869:      Others, the ones that are modifiers of other types,
        !          3870:      are represented by bits in SPECBITS: set the bits for
        !          3871:      the modifiers that appear.  Storage class keywords are also in SPECBITS.
        !          3872: 
        !          3873:      If there is a typedef name or a type, store the type in TYPE.
        !          3874:      This includes builtin typedefs such as `int'.
        !          3875: 
        !          3876:      Set EXPLICIT_INT or EXPLICIT_CHAR if the type is `int' or `char'
        !          3877:      and did not come from a user typedef.
        !          3878: 
        !          3879:      Set LONGLONG if `long' is mentioned twice.  */
        !          3880: 
        !          3881:   for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
        !          3882:     {
        !          3883:       register int i;
        !          3884:       register tree id = TREE_VALUE (spec);
        !          3885: 
        !          3886:       if (id == ridpointers[(int) RID_INT])
        !          3887:        explicit_int = 1;
        !          3888:       if (id == ridpointers[(int) RID_CHAR])
        !          3889:        explicit_char = 1;
        !          3890: 
        !          3891:       if (TREE_CODE (id) == IDENTIFIER_NODE)
        !          3892:        for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
        !          3893:          {
        !          3894:            if (ridpointers[i] == id)
        !          3895:              {
        !          3896:                if (i == (int) RID_LONG && specbits & (1<<i))
        !          3897:                  {
        !          3898:                    if (longlong)
        !          3899:                      error ("`long long long' is too long for GCC");
        !          3900:                    else
        !          3901:                      {
        !          3902:                        if (pedantic)
        !          3903:                          pedwarn ("ANSI C does not support `long long'");
        !          3904:                        longlong = 1;
        !          3905:                      }
        !          3906:                  }
        !          3907:                else if (specbits & (1 << i))
        !          3908:                  pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
        !          3909:                specbits |= 1 << i;
        !          3910:                goto found;
        !          3911:              }
        !          3912:          }
        !          3913:       if (type)
        !          3914:        error ("two or more data types in declaration of `%s'", name);
        !          3915:       /* Actual typedefs come to us as TYPE_DECL nodes.  */
        !          3916:       else if (TREE_CODE (id) == TYPE_DECL)
        !          3917:        {
        !          3918:          type = TREE_TYPE (id);
        !          3919:          typedef_decl = id;
        !          3920:        }
        !          3921:       /* Built-in types come as identifiers.  */
        !          3922:       else if (TREE_CODE (id) == IDENTIFIER_NODE)
        !          3923:        {
        !          3924:          register tree t = lookup_name (id);
        !          3925:          if (TREE_TYPE (t) == error_mark_node)
        !          3926:            ;
        !          3927:          else if (!t || TREE_CODE (t) != TYPE_DECL)
        !          3928:            error ("`%s' fails to be a typedef or built in type",
        !          3929:                   IDENTIFIER_POINTER (id));
        !          3930:          else
        !          3931:            {
        !          3932:              type = TREE_TYPE (t);
        !          3933:              typedef_decl = t;
        !          3934:            }
        !          3935:        }
        !          3936:       else if (TREE_CODE (id) != ERROR_MARK)
        !          3937:        type = id;
        !          3938: 
        !          3939:     found: {}
        !          3940:     }
        !          3941: 
        !          3942:   typedef_type = type;
        !          3943:   if (type)
        !          3944:     size_varies = C_TYPE_VARIABLE_SIZE (type);
        !          3945: 
        !          3946:   /* No type at all: default to `int', and set DEFAULTED_INT
        !          3947:      because it was not a user-defined typedef.  */
        !          3948: 
        !          3949:   if (type == 0)
        !          3950:     {
        !          3951:       if (funcdef_flag && warn_return_type
        !          3952:          && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
        !          3953:                            | (1 << (int) RID_SIGNED) | (1 << (int) RID_UNSIGNED))))
        !          3954:        warn_about_return_type = 1;
        !          3955:       defaulted_int = 1;
        !          3956:       type = integer_type_node;
        !          3957:     }
        !          3958: 
        !          3959:   /* Now process the modifiers that were specified
        !          3960:      and check for invalid combinations.  */
        !          3961: 
        !          3962:   /* Long double is a special combination.  */
        !          3963: 
        !          3964:   if ((specbits & 1 << (int) RID_LONG)
        !          3965:       && TYPE_MAIN_VARIANT (type) == double_type_node)
        !          3966:     {
        !          3967:       specbits &= ~ (1 << (int) RID_LONG);
        !          3968:       type = long_double_type_node;
        !          3969:     }
        !          3970: 
        !          3971:   /* Check all other uses of type modifiers.  */
        !          3972: 
        !          3973:   if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
        !          3974:                  | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
        !          3975:     {
        !          3976:       int ok = 0;
        !          3977: 
        !          3978:       if (TREE_CODE (type) != INTEGER_TYPE)
        !          3979:        error ("long, short, signed or unsigned invalid for `%s'", name);
        !          3980:       else if ((specbits & 1 << (int) RID_LONG)
        !          3981:               && (specbits & 1 << (int) RID_SHORT))
        !          3982:        error ("long and short specified together for `%s'", name);
        !          3983:       else if (((specbits & 1 << (int) RID_LONG)
        !          3984:                || (specbits & 1 << (int) RID_SHORT))
        !          3985:               && explicit_char)
        !          3986:        error ("long or short specified with char for `%s'", name);
        !          3987:       else if (((specbits & 1 << (int) RID_LONG)
        !          3988:                || (specbits & 1 << (int) RID_SHORT))
        !          3989:               && TREE_CODE (type) == REAL_TYPE)
        !          3990:        error ("long or short specified with floating type for `%s'", name);
        !          3991:       else if ((specbits & 1 << (int) RID_SIGNED)
        !          3992:               && (specbits & 1 << (int) RID_UNSIGNED))
        !          3993:        error ("signed and unsigned given together for `%s'", name);
        !          3994:       else
        !          3995:        {
        !          3996:          ok = 1;
        !          3997:          if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
        !          3998:            {
        !          3999:              pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
        !          4000:                       name);
        !          4001:              if (flag_pedantic_errors)
        !          4002:                ok = 0;
        !          4003:            }
        !          4004:        }
        !          4005: 
        !          4006:       /* Discard the type modifiers if they are invalid.  */
        !          4007:       if (! ok)
        !          4008:        {
        !          4009:          specbits &= ~((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
        !          4010:                        | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED));
        !          4011:          longlong = 0;
        !          4012:        }
        !          4013:     }
        !          4014: 
        !          4015:   /* Decide whether an integer type is signed or not.
        !          4016:      Optionally treat bitfields as signed by default.  */
        !          4017:   if (specbits & 1 << (int) RID_UNSIGNED
        !          4018:       /* Traditionally, all bitfields are unsigned.  */
        !          4019:       || (bitfield && flag_traditional
        !          4020:          && (! explicit_flag_signed_bitfields || !flag_signed_bitfields))
        !          4021:       || (bitfield && ! flag_signed_bitfields
        !          4022:          && (explicit_int || defaulted_int || explicit_char
        !          4023:              /* A typedef for plain `int' without `signed'
        !          4024:                 can be controlled just like plain `int'.  */
        !          4025:              || ! (typedef_decl != 0
        !          4026:                    && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
        !          4027:          && TREE_CODE (type) != ENUMERAL_TYPE
        !          4028:          && !(specbits & 1 << (int) RID_SIGNED)))
        !          4029:     {
        !          4030:       if (longlong)
        !          4031:        type = long_long_unsigned_type_node;
        !          4032:       else if (specbits & 1 << (int) RID_LONG)
        !          4033:        type = long_unsigned_type_node;
        !          4034:       else if (specbits & 1 << (int) RID_SHORT)
        !          4035:        type = short_unsigned_type_node;
        !          4036:       else if (type == char_type_node)
        !          4037:        type = unsigned_char_type_node;
        !          4038:       else if (typedef_decl)
        !          4039:        type = unsigned_type (type);
        !          4040:       else
        !          4041:        type = unsigned_type_node;
        !          4042:     }
        !          4043:   else if ((specbits & 1 << (int) RID_SIGNED)
        !          4044:           && type == char_type_node)
        !          4045:     type = signed_char_type_node;
        !          4046:   else if (longlong)
        !          4047:     type = long_long_integer_type_node;
        !          4048:   else if (specbits & 1 << (int) RID_LONG)
        !          4049:     type = long_integer_type_node;
        !          4050:   else if (specbits & 1 << (int) RID_SHORT)
        !          4051:     type = short_integer_type_node;
        !          4052:   else if (specbits & 1 << (int) RID_COMPLEX)
        !          4053:     {
        !          4054:       if (defaulted_int)
        !          4055:        type = complex_double_type_node;
        !          4056:       else if (type == integer_type_node)
        !          4057:        type = complex_integer_type_node;
        !          4058:       else if (type == float_type_node)
        !          4059:        type = complex_float_type_node;
        !          4060:       else if (type == double_type_node)
        !          4061:        type = complex_double_type_node;
        !          4062:       else if (type == long_double_type_node)
        !          4063:        type = complex_long_double_type_node;
        !          4064:       else
        !          4065:        error ("invalid complex type");
        !          4066:     }
        !          4067: 
        !          4068:   /* Set CONSTP if this declaration is `const', whether by
        !          4069:      explicit specification or via a typedef.
        !          4070:      Likewise for VOLATILEP.  */
        !          4071: 
        !          4072:   constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (type);
        !          4073:   volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (type);
        !          4074:   inlinep = !! (specbits & (1 << (int) RID_INLINE));
        !          4075:   if (constp > 1)
        !          4076:     pedwarn ("duplicate `const'");
        !          4077:   if (volatilep > 1)
        !          4078:     pedwarn ("duplicate `volatile'");
        !          4079:   if (! flag_gen_aux_info && (TYPE_READONLY (type) || TYPE_VOLATILE (type)))
        !          4080:     type = TYPE_MAIN_VARIANT (type);
        !          4081: 
        !          4082:   /* Warn if two storage classes are given. Default to `auto'.  */
        !          4083: 
        !          4084:   {
        !          4085:     int nclasses = 0;
        !          4086: 
        !          4087:     if (specbits & 1 << (int) RID_AUTO) nclasses++;
        !          4088:     if (specbits & 1 << (int) RID_STATIC) nclasses++;
        !          4089:     if (specbits & 1 << (int) RID_EXTERN) nclasses++;
        !          4090:     if (specbits & 1 << (int) RID_REGISTER) nclasses++;
        !          4091:     if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
        !          4092:     if (specbits & 1 << (int) RID_ITERATOR) nclasses++;
        !          4093: 
        !          4094:     /* Warn about storage classes that are invalid for certain
        !          4095:        kinds of declarations (parameters, typenames, etc.).  */
        !          4096: 
        !          4097:     if (nclasses > 1)
        !          4098:       error ("multiple storage classes in declaration of `%s'", name);
        !          4099:     else if (funcdef_flag
        !          4100:             && (specbits
        !          4101:                 & ((1 << (int) RID_REGISTER)
        !          4102:                    | (1 << (int) RID_AUTO)
        !          4103:                    | (1 << (int) RID_TYPEDEF))))
        !          4104:       {
        !          4105:        if (specbits & 1 << (int) RID_AUTO
        !          4106:            && (pedantic || current_binding_level == global_binding_level))
        !          4107:          pedwarn ("function definition declared `auto'");
        !          4108:        if (specbits & 1 << (int) RID_REGISTER)
        !          4109:          error ("function definition declared `register'");
        !          4110:        if (specbits & 1 << (int) RID_TYPEDEF)
        !          4111:          error ("function definition declared `typedef'");
        !          4112:        specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
        !          4113:                       | (1 << (int) RID_AUTO));
        !          4114:       }
        !          4115:     else if (decl_context != NORMAL && nclasses > 0)
        !          4116:       {
        !          4117:        if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
        !          4118:          ;
        !          4119:        else
        !          4120:          {
        !          4121:            error ((decl_context == FIELD
        !          4122:                    ? "storage class specified for structure field `%s'"
        !          4123:                    : (decl_context == PARM
        !          4124:                       ? "storage class specified for parameter `%s'"
        !          4125:                       : "storage class specified for typename")),
        !          4126:                   name);
        !          4127:            specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
        !          4128:                           | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
        !          4129:                           | (1 << (int) RID_EXTERN));
        !          4130:          }
        !          4131:       }
        !          4132:     else if (specbits & 1 << (int) RID_EXTERN && initialized && ! funcdef_flag)
        !          4133:       {
        !          4134:        /* `extern' with initialization is invalid if not at top level.  */
        !          4135:        if (current_binding_level == global_binding_level)
        !          4136:          warning ("`%s' initialized and declared `extern'", name);
        !          4137:        else
        !          4138:          error ("`%s' has both `extern' and initializer", name);
        !          4139:       }
        !          4140:     else if (specbits & 1 << (int) RID_EXTERN && funcdef_flag
        !          4141:             && current_binding_level != global_binding_level)
        !          4142:       error ("nested function `%s' declared `extern'", name);
        !          4143:     else if (current_binding_level == global_binding_level
        !          4144:             && specbits & (1 << (int) RID_AUTO))
        !          4145:       error ("top-level declaration of `%s' specifies `auto'", name);
        !          4146:     else if ((specbits & 1 << (int) RID_ITERATOR)
        !          4147:             && TREE_CODE (declarator) != IDENTIFIER_NODE)
        !          4148:       {
        !          4149:        error ("iterator `%s' has derived type", name);
        !          4150:        type = error_mark_node;
        !          4151:       }
        !          4152:     else if ((specbits & 1 << (int) RID_ITERATOR)
        !          4153:             && TREE_CODE (type) != INTEGER_TYPE)
        !          4154:       {
        !          4155:        error ("iterator `%s' has noninteger type", name);
        !          4156:        type = error_mark_node;
        !          4157:       }
        !          4158:   }
        !          4159: 
        !          4160:   /* Now figure out the structure of the declarator proper.
        !          4161:      Descend through it, creating more complex types, until we reach
        !          4162:      the declared identifier (or NULL_TREE, in an absolute declarator).  */
        !          4163: 
        !          4164:   while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
        !          4165:     {
        !          4166:       if (type == error_mark_node)
        !          4167:        {
        !          4168:          declarator = TREE_OPERAND (declarator, 0);
        !          4169:          continue;
        !          4170:        }
        !          4171: 
        !          4172:       /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
        !          4173:         an INDIRECT_REF (for *...),
        !          4174:         a CALL_EXPR (for ...(...)),
        !          4175:         an identifier (for the name being declared)
        !          4176:         or a null pointer (for the place in an absolute declarator
        !          4177:         where the name was omitted).
        !          4178:         For the last two cases, we have just exited the loop.
        !          4179: 
        !          4180:         At this point, TYPE is the type of elements of an array,
        !          4181:         or for a function to return, or for a pointer to point to.
        !          4182:         After this sequence of ifs, TYPE is the type of the
        !          4183:         array or function or pointer, and DECLARATOR has had its
        !          4184:         outermost layer removed.  */
        !          4185: 
        !          4186:       if (TREE_CODE (declarator) == ARRAY_REF)
        !          4187:        {
        !          4188:          register tree itype = NULL_TREE;
        !          4189:          register tree size = TREE_OPERAND (declarator, 1);
        !          4190:          /* An uninitialized decl with `extern' is a reference.  */
        !          4191:          int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
        !          4192: 
        !          4193:          declarator = TREE_OPERAND (declarator, 0);
        !          4194: 
        !          4195:          /* Check for some types that there cannot be arrays of.  */
        !          4196: 
        !          4197:          if (TYPE_MAIN_VARIANT (type) == void_type_node)
        !          4198:            {
        !          4199:              error ("declaration of `%s' as array of voids", name);
        !          4200:              type = error_mark_node;
        !          4201:            }
        !          4202: 
        !          4203:          if (TREE_CODE (type) == FUNCTION_TYPE)
        !          4204:            {
        !          4205:              error ("declaration of `%s' as array of functions", name);
        !          4206:              type = error_mark_node;
        !          4207:            }
        !          4208: 
        !          4209:          if (size == error_mark_node)
        !          4210:            type = error_mark_node;
        !          4211: 
        !          4212:          if (type == error_mark_node)
        !          4213:            continue;
        !          4214: 
        !          4215:          /* If this is a block level extern, it must live past the end
        !          4216:             of the function so that we can check it against other extern
        !          4217:             declarations (IDENTIFIER_LIMBO_VALUE).  */
        !          4218:          if (extern_ref && allocation_temporary_p ())
        !          4219:            end_temporary_allocation ();
        !          4220: 
        !          4221:          /* If size was specified, set ITYPE to a range-type for that size.
        !          4222:             Otherwise, ITYPE remains null.  finish_decl may figure it out
        !          4223:             from an initial value.  */
        !          4224: 
        !          4225:          if (size)
        !          4226:            {
        !          4227:              /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
        !          4228:              STRIP_TYPE_NOPS (size);
        !          4229: 
        !          4230:              if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
        !          4231:                  && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
        !          4232:                {
        !          4233:                  error ("size of array `%s' has non-integer type", name);
        !          4234:                  size = integer_one_node;
        !          4235:                }
        !          4236:              if (pedantic && integer_zerop (size))
        !          4237:                pedwarn ("ANSI C forbids zero-size array `%s'", name);
        !          4238:              if (TREE_CODE (size) == INTEGER_CST)
        !          4239:                {
        !          4240:                  constant_expression_warning (size);
        !          4241:                  if (INT_CST_LT (size, integer_zero_node))
        !          4242:                    {
        !          4243:                      error ("size of array `%s' is negative", name);
        !          4244:                      size = integer_one_node;
        !          4245:                    }
        !          4246:                  itype = build_index_type (size_binop (MINUS_EXPR, size,
        !          4247:                                                        size_one_node));
        !          4248:                }
        !          4249:              else
        !          4250:                {
        !          4251:                  if (pedantic)
        !          4252:                    {
        !          4253:                      if (TREE_CONSTANT (size))
        !          4254:                        pedwarn ("ANSI C forbids array `%s' whose size can't be evaluated", name);
        !          4255:                      else
        !          4256:                        pedwarn ("ANSI C forbids variable-size array `%s'", name);
        !          4257:                    }
        !          4258:                  itype = build_binary_op (MINUS_EXPR, size, integer_one_node,
        !          4259:                                           1);
        !          4260:                  /* Make sure the array size remains visibly nonconstant
        !          4261:                     even if it is (eg) a const variable with known value.  */
        !          4262:                  size_varies = 1;
        !          4263:                  itype = variable_size (itype);
        !          4264:                  itype = build_index_type (itype);
        !          4265:                }
        !          4266:            }
        !          4267: 
        !          4268: #if 0 /* This had bad results for pointers to arrays, as in
        !          4269:         union incomplete (*foo)[4];  */
        !          4270:          /* Complain about arrays of incomplete types, except in typedefs.  */
        !          4271: 
        !          4272:          if (TYPE_SIZE (type) == 0
        !          4273:              /* Avoid multiple warnings for nested array types.  */
        !          4274:              && TREE_CODE (type) != ARRAY_TYPE
        !          4275:              && !(specbits & (1 << (int) RID_TYPEDEF))
        !          4276:              && !C_TYPE_BEING_DEFINED (type))
        !          4277:            warning ("array type has incomplete element type");
        !          4278: #endif
        !          4279: 
        !          4280: #if 0  /* We shouldn't have a function type here at all!
        !          4281:          Functions aren't allowed as array elements.  */
        !          4282:          if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
        !          4283:              && (constp || volatilep))
        !          4284:            pedwarn ("ANSI C forbids const or volatile function types");
        !          4285: #endif
        !          4286: 
        !          4287:          /* Build the array type itself, then merge any constancy or
        !          4288:             volatility into the target type.  We must do it in this order
        !          4289:             to ensure that the TYPE_MAIN_VARIANT field of the array type
        !          4290:             is set correctly.  */
        !          4291: 
        !          4292:          type = build_array_type (type, itype);
        !          4293:          if (constp || volatilep)
        !          4294:            type = c_build_type_variant (type, constp, volatilep);
        !          4295: 
        !          4296: #if 0  /* don't clear these; leave them set so that the array type
        !          4297:           or the variable is itself const or volatile.  */
        !          4298:          constp = 0;
        !          4299:          volatilep = 0;
        !          4300: #endif
        !          4301: 
        !          4302:          if (size_varies)
        !          4303:            C_TYPE_VARIABLE_SIZE (type) = 1;
        !          4304:        }
        !          4305:       else if (TREE_CODE (declarator) == CALL_EXPR)
        !          4306:        {
        !          4307:          int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
        !          4308:                            || current_binding_level == global_binding_level);
        !          4309:          tree arg_types;
        !          4310: 
        !          4311:          /* Declaring a function type.
        !          4312:             Make sure we have a valid type for the function to return.  */
        !          4313:          if (type == error_mark_node)
        !          4314:            continue;
        !          4315: 
        !          4316:          size_varies = 0;
        !          4317: 
        !          4318:          /* Warn about some types functions can't return.  */
        !          4319: 
        !          4320:          if (TREE_CODE (type) == FUNCTION_TYPE)
        !          4321:            {
        !          4322:              error ("`%s' declared as function returning a function", name);
        !          4323:              type = integer_type_node;
        !          4324:            }
        !          4325:          if (TREE_CODE (type) == ARRAY_TYPE)
        !          4326:            {
        !          4327:              error ("`%s' declared as function returning an array", name);
        !          4328:              type = integer_type_node;
        !          4329:            }
        !          4330: 
        !          4331: #ifndef TRADITIONAL_RETURN_FLOAT
        !          4332:          /* Traditionally, declaring return type float means double.  */
        !          4333: 
        !          4334:          if (flag_traditional && TYPE_MAIN_VARIANT (type) == float_type_node)
        !          4335:            type = double_type_node;
        !          4336: #endif /* TRADITIONAL_RETURN_FLOAT */
        !          4337: 
        !          4338:          /* If this is a block level extern, it must live past the end
        !          4339:             of the function so that we can check it against other extern
        !          4340:             declarations (IDENTIFIER_LIMBO_VALUE).  */
        !          4341:          if (extern_ref && allocation_temporary_p ())
        !          4342:            end_temporary_allocation ();
        !          4343: 
        !          4344:          /* Construct the function type and go to the next
        !          4345:             inner layer of declarator.  */
        !          4346: 
        !          4347:          arg_types = grokparms (TREE_OPERAND (declarator, 1),
        !          4348:                                 funcdef_flag
        !          4349:                                 /* Say it's a definition
        !          4350:                                    only for the CALL_EXPR
        !          4351:                                    closest to the identifier.  */
        !          4352:                                 && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE);
        !          4353: #if 0 /* This seems to be false.  We turn off temporary allocation
        !          4354:         above in this function if -traditional.
        !          4355:         And this code caused inconsistent results with prototypes:
        !          4356:         callers would ignore them, and pass arguments wrong.  */
        !          4357: 
        !          4358:          /* Omit the arg types if -traditional, since the arg types
        !          4359:             and the list links might not be permanent.  */
        !          4360:          type = build_function_type (type,
        !          4361:                                      flag_traditional 
        !          4362:                                      ? NULL_TREE : arg_types);
        !          4363: #endif
        !          4364:          /* ANSI seems to say that `const int foo ();'
        !          4365:             does not make the function foo const.  */
        !          4366:          if (constp || volatilep)
        !          4367:            type = c_build_type_variant (type, constp, volatilep);
        !          4368:          constp = 0;
        !          4369:          volatilep = 0;
        !          4370: 
        !          4371:          type = build_function_type (type, arg_types);
        !          4372:          declarator = TREE_OPERAND (declarator, 0);
        !          4373: 
        !          4374:          /* Set the TYPE_CONTEXTs for each tagged type which is local to
        !          4375:             the formal parameter list of this FUNCTION_TYPE to point to
        !          4376:             the FUNCTION_TYPE node itself.  */
        !          4377: 
        !          4378:          {
        !          4379:            register tree link;
        !          4380: 
        !          4381:            for (link = current_function_parm_tags;
        !          4382:                 link;
        !          4383:                 link = TREE_CHAIN (link))
        !          4384:              TYPE_CONTEXT (TREE_VALUE (link)) = type;
        !          4385:          }
        !          4386:        }
        !          4387:       else if (TREE_CODE (declarator) == INDIRECT_REF)
        !          4388:        {
        !          4389:          /* Merge any constancy or volatility into the target type
        !          4390:             for the pointer.  */
        !          4391: 
        !          4392:          if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
        !          4393:              && (constp || volatilep))
        !          4394:            pedwarn ("ANSI C forbids const or volatile function types");
        !          4395:          if (constp || volatilep)
        !          4396:            type = c_build_type_variant (type, constp, volatilep);
        !          4397:          constp = 0;
        !          4398:          volatilep = 0;
        !          4399:          size_varies = 0;
        !          4400: 
        !          4401:          type = build_pointer_type (type);
        !          4402: 
        !          4403:          /* Process a list of type modifier keywords
        !          4404:             (such as const or volatile) that were given inside the `*'.  */
        !          4405: 
        !          4406:          if (TREE_TYPE (declarator))
        !          4407:            {
        !          4408:              register tree typemodlist;
        !          4409:              int erred = 0;
        !          4410:              for (typemodlist = TREE_TYPE (declarator); typemodlist;
        !          4411:                   typemodlist = TREE_CHAIN (typemodlist))
        !          4412:                {
        !          4413:                  if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
        !          4414:                    constp++;
        !          4415:                  else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
        !          4416:                    volatilep++;
        !          4417:                  else if (!erred)
        !          4418:                    {
        !          4419:                      erred = 1;
        !          4420:                      error ("invalid type modifier within pointer declarator");
        !          4421:                    }
        !          4422:                }
        !          4423:              if (constp > 1)
        !          4424:                pedwarn ("duplicate `const'");
        !          4425:              if (volatilep > 1)
        !          4426:                pedwarn ("duplicate `volatile'");
        !          4427:            }
        !          4428: 
        !          4429:          declarator = TREE_OPERAND (declarator, 0);
        !          4430:        }
        !          4431:       else
        !          4432:        abort ();
        !          4433: 
        !          4434:     }
        !          4435: 
        !          4436:   /* Now TYPE has the actual type.  */
        !          4437: 
        !          4438:   /* If this is declaring a typedef name, return a TYPE_DECL.  */
        !          4439: 
        !          4440:   if (specbits & (1 << (int) RID_TYPEDEF))
        !          4441:     {
        !          4442:       tree decl;
        !          4443:       /* Note that the grammar rejects storage classes
        !          4444:         in typenames, fields or parameters */
        !          4445:       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
        !          4446:          && (constp || volatilep))
        !          4447:        pedwarn ("ANSI C forbids const or volatile function types");
        !          4448:       if (constp || volatilep)
        !          4449:        type = c_build_type_variant (type, constp, volatilep);
        !          4450:       pop_obstacks ();
        !          4451:       decl = build_decl (TYPE_DECL, declarator, type);
        !          4452:       if ((specbits & (1 << (int) RID_SIGNED))
        !          4453:          || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
        !          4454:        C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
        !          4455:       return decl;
        !          4456:     }
        !          4457: 
        !          4458:   /* Detect the case of an array type of unspecified size
        !          4459:      which came, as such, direct from a typedef name.
        !          4460:      We must copy the type, so that each identifier gets
        !          4461:      a distinct type, so that each identifier's size can be
        !          4462:      controlled separately by its own initializer.  */
        !          4463: 
        !          4464:   if (type != 0 && typedef_type != 0
        !          4465:       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type)
        !          4466:       && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0)
        !          4467:     {
        !          4468:       type = build_array_type (TREE_TYPE (type), 0);
        !          4469:       if (size_varies)
        !          4470:        C_TYPE_VARIABLE_SIZE (type) = 1;
        !          4471:     }
        !          4472: 
        !          4473:   /* If this is a type name (such as, in a cast or sizeof),
        !          4474:      compute the type and return it now.  */
        !          4475: 
        !          4476:   if (decl_context == TYPENAME)
        !          4477:     {
        !          4478:       /* Note that the grammar rejects storage classes
        !          4479:         in typenames, fields or parameters */
        !          4480:       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
        !          4481:          && (constp || volatilep))
        !          4482:        pedwarn ("ANSI C forbids const or volatile function types");
        !          4483:       if (constp || volatilep)
        !          4484:        type = c_build_type_variant (type, constp, volatilep);
        !          4485:       pop_obstacks ();
        !          4486:       return type;
        !          4487:     }
        !          4488: 
        !          4489:   /* Aside from typedefs and type names (handle above),
        !          4490:      `void' at top level (not within pointer)
        !          4491:      is allowed only in public variables.
        !          4492:      We don't complain about parms either, but that is because
        !          4493:      a better error message can be made later.  */
        !          4494: 
        !          4495:   if (TYPE_MAIN_VARIANT (type) == void_type_node && decl_context != PARM
        !          4496:       && ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
        !          4497:            && ((specbits & (1 << (int) RID_EXTERN))
        !          4498:                || (current_binding_level == global_binding_level
        !          4499:                    && !(specbits
        !          4500:                         & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)))))))
        !          4501:     {
        !          4502:       error ("variable or field `%s' declared void",
        !          4503:             IDENTIFIER_POINTER (declarator));
        !          4504:       type = integer_type_node;
        !          4505:     }
        !          4506: 
        !          4507:   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
        !          4508:      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
        !          4509: 
        !          4510:   {
        !          4511:     register tree decl;
        !          4512: 
        !          4513:     if (decl_context == PARM)
        !          4514:       {
        !          4515:        tree type_as_written = type;
        !          4516:        tree main_type;
        !          4517: 
        !          4518:        /* A parameter declared as an array of T is really a pointer to T.
        !          4519:           One declared as a function is really a pointer to a function.  */
        !          4520: 
        !          4521:        if (TREE_CODE (type) == ARRAY_TYPE)
        !          4522:          {
        !          4523:            /* Transfer const-ness of array into that of type pointed to.  */
        !          4524:            type = TREE_TYPE (type);
        !          4525:            if (constp || volatilep)
        !          4526:              type = c_build_type_variant (type, constp, volatilep);
        !          4527:            type = build_pointer_type (type);
        !          4528:            volatilep = constp = 0;
        !          4529:            size_varies = 0;
        !          4530:          }
        !          4531:        else if (TREE_CODE (type) == FUNCTION_TYPE)
        !          4532:          {
        !          4533:            if (pedantic && (constp || volatilep))
        !          4534:              pedwarn ("ANSI C forbids const or volatile function types");
        !          4535:            if (constp || volatilep)
        !          4536:              type = c_build_type_variant (type, constp, volatilep);
        !          4537:            type = build_pointer_type (type);
        !          4538:            volatilep = constp = 0;
        !          4539:          }
        !          4540: 
        !          4541:        decl = build_decl (PARM_DECL, declarator, type);
        !          4542:        if (size_varies)
        !          4543:          C_DECL_VARIABLE_SIZE (decl) = 1;
        !          4544: 
        !          4545:        /* Compute the type actually passed in the parmlist,
        !          4546:           for the case where there is no prototype.
        !          4547:           (For example, shorts and chars are passed as ints.)
        !          4548:           When there is a prototype, this is overridden later.  */
        !          4549: 
        !          4550:        DECL_ARG_TYPE (decl) = type;
        !          4551:        main_type = (type == error_mark_node
        !          4552:                     ? error_mark_node
        !          4553:                     : TYPE_MAIN_VARIANT (type));
        !          4554:        if (main_type == float_type_node)
        !          4555:          DECL_ARG_TYPE (decl) = double_type_node;
        !          4556:        /* Don't use TYPE_PRECISION to decide whether to promote,
        !          4557:           because we should convert short if it's the same size as int,
        !          4558:           but we should not convert long if it's the same size as int.  */
        !          4559:        else if (TREE_CODE (main_type) != ERROR_MARK
        !          4560:                 && C_PROMOTING_INTEGER_TYPE_P (main_type))
        !          4561:          {
        !          4562:            if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
        !          4563:                && TREE_UNSIGNED (type))
        !          4564:              DECL_ARG_TYPE (decl) = unsigned_type_node;
        !          4565:            else
        !          4566:              DECL_ARG_TYPE (decl) = integer_type_node;
        !          4567:          }
        !          4568: 
        !          4569:        DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
        !          4570:       }
        !          4571:     else if (decl_context == FIELD)
        !          4572:       {
        !          4573:        /* Structure field.  It may not be a function.  */
        !          4574: 
        !          4575:        if (TREE_CODE (type) == FUNCTION_TYPE)
        !          4576:          {
        !          4577:            error ("field `%s' declared as a function",
        !          4578:                   IDENTIFIER_POINTER (declarator));
        !          4579:            type = build_pointer_type (type);
        !          4580:          }
        !          4581:        else if (TREE_CODE (type) != ERROR_MARK && TYPE_SIZE (type) == 0)
        !          4582:          {
        !          4583:            error ("field `%s' has incomplete type",
        !          4584:                   IDENTIFIER_POINTER (declarator));
        !          4585:            type = error_mark_node;
        !          4586:          }
        !          4587:        /* Move type qualifiers down to element of an array.  */
        !          4588:        if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
        !          4589:          {
        !          4590:            type = build_array_type (c_build_type_variant (TREE_TYPE (type),
        !          4591:                                                           constp, volatilep),
        !          4592:                                     TYPE_DOMAIN (type));
        !          4593: #if 0 /* Leave the field const or volatile as well.  */
        !          4594:            constp = volatilep = 0;
        !          4595: #endif
        !          4596:          }
        !          4597:        decl = build_decl (FIELD_DECL, declarator, type);
        !          4598:        if (size_varies)
        !          4599:          C_DECL_VARIABLE_SIZE (decl) = 1;
        !          4600:       }
        !          4601:     else if (TREE_CODE (type) == FUNCTION_TYPE)
        !          4602:       {
        !          4603:        /* Every function declaration is "external"
        !          4604:           except for those which are inside a function body
        !          4605:           in which `auto' is used.
        !          4606:           That is a case not specified by ANSI C,
        !          4607:           and we use it for forward declarations for nested functions.  */
        !          4608:        int extern_ref = (!(specbits & (1 << (int) RID_AUTO))
        !          4609:                          || current_binding_level == global_binding_level);
        !          4610: 
        !          4611:        if (specbits & (1 << (int) RID_AUTO)
        !          4612:            && (pedantic || current_binding_level == global_binding_level))
        !          4613:          pedwarn ("invalid storage class for function `%s'",
        !          4614:                 IDENTIFIER_POINTER (declarator));
        !          4615:        if (specbits & (1 << (int) RID_REGISTER))
        !          4616:          error ("invalid storage class for function `%s'",
        !          4617:                 IDENTIFIER_POINTER (declarator));
        !          4618:        /* Function declaration not at top level.
        !          4619:           Storage classes other than `extern' are not allowed
        !          4620:           and `extern' makes no difference.  */
        !          4621:        if (current_binding_level != global_binding_level
        !          4622:            && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
        !          4623:            && pedantic)
        !          4624:          pedwarn ("invalid storage class for function `%s'",
        !          4625:                   IDENTIFIER_POINTER (declarator));
        !          4626: 
        !          4627:        /* If this is a block level extern, it must live past the end
        !          4628:           of the function so that we can check it against other
        !          4629:           extern declarations (IDENTIFIER_LIMBO_VALUE).  */
        !          4630:        if (extern_ref && allocation_temporary_p ())
        !          4631:          end_temporary_allocation ();
        !          4632: 
        !          4633:        decl = build_decl (FUNCTION_DECL, declarator, type);
        !          4634: 
        !          4635:        if (pedantic && (constp || volatilep)
        !          4636:            && ! DECL_IN_SYSTEM_HEADER (decl))
        !          4637:          pedwarn ("ANSI C forbids const or volatile functions");
        !          4638: 
        !          4639:        if (volatilep
        !          4640:            && TREE_TYPE (TREE_TYPE (decl)) != void_type_node)
        !          4641:          warning ("volatile function returns non-void value");
        !          4642: 
        !          4643:        if (extern_ref)
        !          4644:          DECL_EXTERNAL (decl) = 1;
        !          4645:        /* Record absence of global scope for `static' or `auto'.  */
        !          4646:        TREE_PUBLIC (decl)
        !          4647:          = !(specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_AUTO)));
        !          4648: 
        !          4649: #ifdef NeXT
        !          4650: #ifdef HPPA
        !          4651:        /* record that this is a vararg/stdarg function which must 
        !          4652:           be taken special care of when it is called. */
        !          4653: 
        !          4654:        {
        !          4655:          tree last = tree_last (TYPE_ARG_TYPES (type));
        !          4656:          
        !          4657:          if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last)) 
        !          4658:                       != void_type_node))
        !          4659:            add_vararg_func(IDENTIFIER_POINTER(declarator), '1');
        !          4660:          else
        !          4661:            add_vararg_func(IDENTIFIER_POINTER(declarator), '0');
        !          4662:        }
        !          4663: #endif
        !          4664: #endif
        !          4665: 
        !          4666:        /* Record presence of `inline', if it is reasonable.  */
        !          4667:        if (inlinep)
        !          4668:          {
        !          4669:            tree last = tree_last (TYPE_ARG_TYPES (type));
        !          4670: 
        !          4671:            if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
        !          4672:              warning ("cannot inline function `main'");
        !          4673:            else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last))
        !          4674:                              != void_type_node))
        !          4675:              warning ("inline declaration ignored for function with `...'");
        !          4676:            else
        !          4677:              /* Assume that otherwise the function can be inlined.  */
        !          4678:              DECL_INLINE (decl) = 1;
        !          4679: 
        !          4680:            if (specbits & (1 << (int) RID_EXTERN))
        !          4681:              current_extern_inline = 1;
        !          4682:          }
        !          4683:       }
        !          4684:     else
        !          4685:       {
        !          4686:        /* It's a variable.  */
        !          4687:        /* An uninitialized decl with `extern' is a reference.  */
        !          4688:        int extern_ref = !initialized && (specbits & (1 << (int) RID_EXTERN));
        !          4689: 
        !          4690:        /* Move type qualifiers down to element of an array.  */
        !          4691:        if (TREE_CODE (type) == ARRAY_TYPE && (constp || volatilep))
        !          4692:          {
        !          4693:            type = build_array_type (c_build_type_variant (TREE_TYPE (type),
        !          4694:                                                           constp, volatilep),
        !          4695:                                     TYPE_DOMAIN (type));
        !          4696: #if 0 /* Leave the variable const or volatile as well.  */
        !          4697:            constp = volatilep = 0;
        !          4698: #endif
        !          4699:          }
        !          4700: 
        !          4701:        /* If this is a block level extern, it must live past the end
        !          4702:           of the function so that we can check it against other
        !          4703:           extern declarations (IDENTIFIER_LIMBO_VALUE).  */
        !          4704:        if (extern_ref && allocation_temporary_p ())
        !          4705:          end_temporary_allocation ();
        !          4706: 
        !          4707:        decl = build_decl (VAR_DECL, declarator, type);
        !          4708:        if (size_varies)
        !          4709:          C_DECL_VARIABLE_SIZE (decl) = 1;
        !          4710: 
        !          4711:        if (inlinep)
        !          4712:          pedwarn_with_decl (decl, "variable `%s' declared `inline'");
        !          4713: 
        !          4714:        DECL_EXTERNAL (decl) = extern_ref;
        !          4715: 
        !          4716:        if (   !initialized
        !          4717:            && !extern_ref
        !          4718:            &&  TREE_CODE (type) == ARRAY_TYPE 
        !          4719:            &&  DECL_SIZE (decl) == NULL_TREE)
        !          4720:          {
        !          4721:            warning_with_decl (decl, "variable `%s' is implicitly extern");
        !          4722:            DECL_EXTERNAL (decl) = 1;
        !          4723:          }
        !          4724: 
        !          4725:        /* At top level, the presence of a `static' or `register' storage
        !          4726:           class specifier, or the absence of all storage class specifiers
        !          4727:           makes this declaration a definition (perhaps tentative).  Also,
        !          4728:           the absence of both `static' and `register' makes it public.  */
        !          4729:        if (current_binding_level == global_binding_level)
        !          4730:          {
        !          4731:            TREE_PUBLIC (decl)
        !          4732:              = !(specbits
        !          4733:                  & ((1 << (int) RID_STATIC) | (1 << (int) RID_REGISTER)));
        !          4734:            TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
        !          4735:          }
        !          4736:        /* Not at top level, only `static' makes a static definition.  */
        !          4737:        else
        !          4738:          {
        !          4739:            TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
        !          4740:            TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
        !          4741:          }
        !          4742: 
        !          4743:        if (specbits & 1 << (int) RID_ITERATOR)
        !          4744:          ITERATOR_P (decl) = 1;
        !          4745:       }
        !          4746: 
        !          4747:     /* Record `register' declaration for warnings on &
        !          4748:        and in case doing stupid register allocation.  */
        !          4749: 
        !          4750:     if (specbits & (1 << (int) RID_REGISTER))
        !          4751:       DECL_REGISTER (decl) = 1;
        !          4752: 
        !          4753:     /* Record constancy and volatility.  */
        !          4754: 
        !          4755:     if (constp)
        !          4756:       TREE_READONLY (decl) = 1;
        !          4757:     if (volatilep)
        !          4758:       {
        !          4759:        TREE_SIDE_EFFECTS (decl) = 1;
        !          4760:        TREE_THIS_VOLATILE (decl) = 1;
        !          4761:       }
        !          4762:     /* If a type has volatile components, it should be stored in memory.
        !          4763:        Otherwise, the fact that those components are volatile
        !          4764:        will be ignored, and would even crash the compiler.  */
        !          4765:     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl)))
        !          4766:       mark_addressable (decl);
        !          4767: 
        !          4768:     pop_obstacks ();
        !          4769: 
        !          4770:     return decl;
        !          4771:   }
        !          4772: }
        !          4773: 
        !          4774: /* Decode the parameter-list info for a function type or function definition.
        !          4775:    The argument is the value returned by `get_parm_info' (or made in parse.y
        !          4776:    if there is an identifier list instead of a parameter decl list).
        !          4777:    These two functions are separate because when a function returns
        !          4778:    or receives functions then each is called multiple times but the order
        !          4779:    of calls is different.  The last call to `grokparms' is always the one
        !          4780:    that contains the formal parameter names of a function definition.
        !          4781: 
        !          4782:    Store in `last_function_parms' a chain of the decls of parms.
        !          4783:    Also store in `last_function_parm_tags' a chain of the struct, union,
        !          4784:    and enum tags declared among the parms.
        !          4785: 
        !          4786:    Return a list of arg types to use in the FUNCTION_TYPE for this function.
        !          4787: 
        !          4788:    FUNCDEF_FLAG is nonzero for a function definition, 0 for
        !          4789:    a mere declaration.  A nonempty identifier-list gets an error message
        !          4790:    when FUNCDEF_FLAG is zero.  */
        !          4791: 
        !          4792: static tree
        !          4793: grokparms (parms_info, funcdef_flag)
        !          4794:      tree parms_info;
        !          4795:      int funcdef_flag;
        !          4796: {
        !          4797:   tree first_parm = TREE_CHAIN (parms_info);
        !          4798: 
        !          4799:   last_function_parms = TREE_PURPOSE (parms_info);
        !          4800:   last_function_parm_tags = TREE_VALUE (parms_info);
        !          4801: 
        !          4802:   if (warn_strict_prototypes && first_parm == 0 && !funcdef_flag
        !          4803:       && !in_system_header)
        !          4804:     warning ("function declaration isn't a prototype");
        !          4805: 
        !          4806:   if (first_parm != 0
        !          4807:       && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
        !          4808:     {
        !          4809:       if (! funcdef_flag)
        !          4810:        pedwarn ("parameter names (without types) in function declaration");
        !          4811: 
        !          4812:       last_function_parms = first_parm;
        !          4813:       return 0;
        !          4814:     }
        !          4815:   else
        !          4816:     {
        !          4817:       tree parm;
        !          4818:       tree typelt;
        !          4819:       /* We no longer test FUNCDEF_FLAG.
        !          4820:         If the arg types are incomplete in a declaration,
        !          4821:         they must include undefined tags.
        !          4822:         These tags can never be defined in the scope of the declaration,
        !          4823:         so the types can never be completed,
        !          4824:         and no call can be compiled successfully.  */
        !          4825: #if 0
        !          4826:       /* In a fcn definition, arg types must be complete.  */
        !          4827:       if (funcdef_flag)
        !          4828: #endif
        !          4829:        for (parm = last_function_parms, typelt = first_parm;
        !          4830:             parm;
        !          4831:             parm = TREE_CHAIN (parm))
        !          4832:          /* Skip over any enumeration constants declared here.  */
        !          4833:          if (TREE_CODE (parm) == PARM_DECL)
        !          4834:            {
        !          4835:              /* Barf if the parameter itself has an incomplete type.  */
        !          4836:              tree type = TREE_VALUE (typelt);
        !          4837:              if (TYPE_SIZE (type) == 0)
        !          4838:                {
        !          4839:                  if (funcdef_flag && DECL_NAME (parm) != 0)
        !          4840:                    error ("parameter `%s' has incomplete type",
        !          4841:                           IDENTIFIER_POINTER (DECL_NAME (parm)));
        !          4842:                  else
        !          4843:                    warning ("parameter has incomplete type");
        !          4844:                  if (funcdef_flag)
        !          4845:                    {
        !          4846:                      TREE_VALUE (typelt) = error_mark_node;
        !          4847:                      TREE_TYPE (parm) = error_mark_node;
        !          4848:                    }
        !          4849:                }
        !          4850: #if 0  /* This has been replaced by parm_tags_warning
        !          4851:          which uses a more accurate criterion for what to warn about.  */
        !          4852:              else
        !          4853:                {
        !          4854:                  /* Now warn if is a pointer to an incomplete type.  */
        !          4855:                  while (TREE_CODE (type) == POINTER_TYPE
        !          4856:                         || TREE_CODE (type) == REFERENCE_TYPE)
        !          4857:                    type = TREE_TYPE (type);
        !          4858:                  type = TYPE_MAIN_VARIANT (type);
        !          4859:                  if (TYPE_SIZE (type) == 0)
        !          4860:                    {
        !          4861:                      if (DECL_NAME (parm) != 0)
        !          4862:                        warning ("parameter `%s' points to incomplete type",
        !          4863:                                 IDENTIFIER_POINTER (DECL_NAME (parm)));
        !          4864:                      else
        !          4865:                        warning ("parameter points to incomplete type");
        !          4866:                    }
        !          4867:                }
        !          4868: #endif
        !          4869:              typelt = TREE_CHAIN (typelt);
        !          4870:            }
        !          4871: 
        !          4872:       /* Allocate the list of types the way we allocate a type.  */
        !          4873:       if (first_parm && ! TREE_PERMANENT (first_parm))
        !          4874:        {
        !          4875:          /* Construct a copy of the list of types
        !          4876:             on the saveable obstack.  */
        !          4877:          tree result = NULL;
        !          4878:          for (typelt = first_parm; typelt; typelt = TREE_CHAIN (typelt))
        !          4879:            result = saveable_tree_cons (NULL_TREE, TREE_VALUE (typelt),
        !          4880:                                         result);
        !          4881:          return nreverse (result);
        !          4882:        }
        !          4883:       else
        !          4884:        /* The list we have is permanent already.  */
        !          4885:        return first_parm;
        !          4886:     }
        !          4887: }
        !          4888: 
        !          4889: 
        !          4890: /* Return a tree_list node with info on a parameter list just parsed.
        !          4891:    The TREE_PURPOSE is a chain of decls of those parms.
        !          4892:    The TREE_VALUE is a list of structure, union and enum tags defined.
        !          4893:    The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
        !          4894:    This tree_list node is later fed to `grokparms'.
        !          4895: 
        !          4896:    VOID_AT_END nonzero means append `void' to the end of the type-list.
        !          4897:    Zero means the parmlist ended with an ellipsis so don't append `void'.  */
        !          4898: 
        !          4899: tree
        !          4900: get_parm_info (void_at_end)
        !          4901:      int void_at_end;
        !          4902: {
        !          4903:   register tree decl, t;
        !          4904:   register tree types = 0;
        !          4905:   int erred = 0;
        !          4906:   tree tags = gettags ();
        !          4907:   tree parms = getdecls ();
        !          4908:   tree new_parms = 0;
        !          4909:   tree order = current_binding_level->parm_order;
        !          4910: 
        !          4911:   /* Just `void' (and no ellipsis) is special.  There are really no parms.  */
        !          4912:   if (void_at_end && parms != 0
        !          4913:       && TREE_CHAIN (parms) == 0
        !          4914:       && TYPE_MAIN_VARIANT (TREE_TYPE (parms)) == void_type_node
        !          4915:       && DECL_NAME (parms) == 0)
        !          4916:     {
        !          4917:       parms = NULL_TREE;
        !          4918:       storedecls (NULL_TREE);
        !          4919:       return saveable_tree_cons (NULL_TREE, NULL_TREE,
        !          4920:                                 saveable_tree_cons (NULL_TREE, void_type_node, NULL_TREE));
        !          4921:     }
        !          4922: 
        !          4923:   /* Extract enumerator values and other non-parms declared with the parms.
        !          4924:      Likewise any forward parm decls that didn't have real parm decls.  */
        !          4925:   for (decl = parms; decl; )
        !          4926:     {
        !          4927:       tree next = TREE_CHAIN (decl);
        !          4928: 
        !          4929:       if (TREE_CODE (decl) != PARM_DECL)
        !          4930:        {
        !          4931:          TREE_CHAIN (decl) = new_parms;
        !          4932:          new_parms = decl;
        !          4933:        }
        !          4934:       else if (TREE_ASM_WRITTEN (decl))
        !          4935:        {
        !          4936:          error_with_decl (decl, "parameter `%s' has just a forward declaration");
        !          4937:          TREE_CHAIN (decl) = new_parms;
        !          4938:          new_parms = decl;
        !          4939:        }
        !          4940:       decl = next;
        !          4941:     }
        !          4942: 
        !          4943:   /* Put the parm decls back in the order they were in in the parm list.  */
        !          4944:   for (t = order; t; t = TREE_CHAIN (t))
        !          4945:     {
        !          4946:       if (TREE_CHAIN (t))
        !          4947:        TREE_CHAIN (TREE_VALUE (t)) = TREE_VALUE (TREE_CHAIN (t));
        !          4948:       else
        !          4949:        TREE_CHAIN (TREE_VALUE (t)) = 0;
        !          4950:     }
        !          4951: 
        !          4952:   new_parms = chainon (order ? nreverse (TREE_VALUE (order)) : 0,
        !          4953:                       new_parms);
        !          4954: 
        !          4955:   /* Store the parmlist in the binding level since the old one
        !          4956:      is no longer a valid list.  (We have changed the chain pointers.)  */
        !          4957:   storedecls (new_parms);
        !          4958: 
        !          4959:   for (decl = new_parms; decl; decl = TREE_CHAIN (decl))
        !          4960:     /* There may also be declarations for enumerators if an enumeration
        !          4961:        type is declared among the parms.  Ignore them here.  */
        !          4962:     if (TREE_CODE (decl) == PARM_DECL)
        !          4963:       {
        !          4964:        /* Since there is a prototype,
        !          4965:           args are passed in their declared types.  */
        !          4966:        tree type = TREE_TYPE (decl);
        !          4967:        DECL_ARG_TYPE (decl) = type;
        !          4968: #ifdef PROMOTE_PROTOTYPES
        !          4969:        if ((TREE_CODE (type) == INTEGER_TYPE
        !          4970:             || TREE_CODE (type) == ENUMERAL_TYPE)
        !          4971:            && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
        !          4972:          DECL_ARG_TYPE (decl) = integer_type_node;
        !          4973: #endif
        !          4974: 
        !          4975:        types = saveable_tree_cons (NULL_TREE, TREE_TYPE (decl), types);
        !          4976:        if (TYPE_MAIN_VARIANT (TREE_VALUE (types)) == void_type_node && ! erred
        !          4977:            && DECL_NAME (decl) == 0)
        !          4978:          {
        !          4979:            error ("`void' in parameter list must be the entire list");
        !          4980:            erred = 1;
        !          4981:          }
        !          4982:       }
        !          4983: 
        !          4984:   if (void_at_end)
        !          4985:     return saveable_tree_cons (new_parms, tags,
        !          4986:                               nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
        !          4987: 
        !          4988:   return saveable_tree_cons (new_parms, tags, nreverse (types));
        !          4989: }
        !          4990: 
        !          4991: /* At end of parameter list, warn about any struct, union or enum tags
        !          4992:    defined within.  Do so because these types cannot ever become complete.  */
        !          4993: 
        !          4994: void
        !          4995: parmlist_tags_warning ()
        !          4996: {
        !          4997:   tree elt;
        !          4998:   static int already;
        !          4999: 
        !          5000:   for (elt = current_binding_level->tags; elt; elt = TREE_CHAIN (elt))
        !          5001:     {
        !          5002:       enum tree_code code = TREE_CODE (TREE_VALUE (elt));
        !          5003:       /* An anonymous union parm type is meaningful as a GNU extension.
        !          5004:         So don't warn for that.  */
        !          5005:       if (code == UNION_TYPE && !pedantic)
        !          5006:        continue;
        !          5007:       if (TREE_PURPOSE (elt) != 0)
        !          5008:        warning ("`%s %s' declared inside parameter list",
        !          5009:                 (code == RECORD_TYPE ? "struct"
        !          5010:                  : code == UNION_TYPE ? "union"
        !          5011:                  : "enum"),
        !          5012:                 IDENTIFIER_POINTER (TREE_PURPOSE (elt)));
        !          5013:       else
        !          5014:        warning ("anonymous %s declared inside parameter list",
        !          5015:                 (code == RECORD_TYPE ? "struct"
        !          5016:                  : code == UNION_TYPE ? "union"
        !          5017:                  : "enum"));
        !          5018: 
        !          5019:       if (! already)
        !          5020:        {
        !          5021:          warning ("its scope is only this definition or declaration,");
        !          5022:          warning ("which is probably not what you want.");
        !          5023:          already = 1;
        !          5024:        }
        !          5025:     }
        !          5026: }
        !          5027: 
        !          5028: /* Get the struct, enum or union (CODE says which) with tag NAME.
        !          5029:    Define the tag as a forward-reference if it is not defined.  */
        !          5030: 
        !          5031: tree
        !          5032: xref_tag (code, name)
        !          5033:      enum tree_code code;
        !          5034:      tree name;
        !          5035: {
        !          5036:   int temporary = allocation_temporary_p ();
        !          5037: 
        !          5038:   /* If a cross reference is requested, look up the type
        !          5039:      already defined for this tag and return it.  */
        !          5040: 
        !          5041:   register tree ref = lookup_tag (code, name, current_binding_level, 0);
        !          5042:   /* Even if this is the wrong type of tag, return what we found.
        !          5043:      There will be an error message anyway, from pending_xref_error.
        !          5044:      If we create an empty xref just for an invalid use of the type,
        !          5045:      the main result is to create lots of superfluous error messages.  */
        !          5046:   if (ref)
        !          5047:     return ref;
        !          5048: 
        !          5049:   push_obstacks_nochange ();
        !          5050: 
        !          5051:   if (current_binding_level == global_binding_level && temporary)
        !          5052:     end_temporary_allocation ();
        !          5053: 
        !          5054:   /* If no such tag is yet defined, create a forward-reference node
        !          5055:      and record it as the "definition".
        !          5056:      When a real declaration of this type is found,
        !          5057:      the forward-reference will be altered into a real type.  */
        !          5058: 
        !          5059:   ref = make_node (code);
        !          5060:   if (code == ENUMERAL_TYPE)
        !          5061:     {
        !          5062:       /* (In ANSI, Enums can be referred to only if already defined.)  */
        !          5063:       if (pedantic)
        !          5064:        pedwarn ("ANSI C forbids forward references to `enum' types");
        !          5065:       /* Give the type a default layout like unsigned int
        !          5066:         to avoid crashing if it does not get defined.  */
        !          5067:       TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
        !          5068:       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
        !          5069:       TREE_UNSIGNED (ref) = 1;
        !          5070:       TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
        !          5071:       TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
        !          5072:       TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
        !          5073:     }
        !          5074: 
        !          5075:   pushtag (name, ref);
        !          5076: 
        !          5077:   pop_obstacks ();
        !          5078: 
        !          5079:   return ref;
        !          5080: }
        !          5081: 
        !          5082: /* Make sure that the tag NAME is defined *in the current binding level*
        !          5083:    at least as a forward reference.
        !          5084:    CODE says which kind of tag NAME ought to be.
        !          5085: 
        !          5086:    We also do a push_obstacks_nochange
        !          5087:    whose matching pop is in finish_struct.  */
        !          5088: 
        !          5089: tree
        !          5090: start_struct (code, name)
        !          5091:      enum tree_code code;
        !          5092:      tree name;
        !          5093: {
        !          5094:   /* If there is already a tag defined at this binding level
        !          5095:      (as a forward reference), just return it.  */
        !          5096: 
        !          5097:   register tree ref = 0;
        !          5098: 
        !          5099:   push_obstacks_nochange ();
        !          5100:   if (current_binding_level == global_binding_level)
        !          5101:     end_temporary_allocation ();
        !          5102: 
        !          5103:   if (name != 0)
        !          5104:     ref = lookup_tag (code, name, current_binding_level, 1);
        !          5105:   if (ref && TREE_CODE (ref) == code)
        !          5106:     {
        !          5107:       C_TYPE_BEING_DEFINED (ref) = 1;
        !          5108:       if (TYPE_FIELDS (ref))
        !          5109:        error ((code == UNION_TYPE ? "redefinition of `union %s'"
        !          5110:                : "redefinition of `struct %s'"),
        !          5111:               IDENTIFIER_POINTER (name));
        !          5112: 
        !          5113:       return ref;
        !          5114:     }
        !          5115: 
        !          5116:   /* Otherwise create a forward-reference just so the tag is in scope.  */
        !          5117: 
        !          5118:   ref = make_node (code);
        !          5119:   pushtag (name, ref);
        !          5120:   C_TYPE_BEING_DEFINED (ref) = 1;
        !          5121:   return ref;
        !          5122: }
        !          5123: 
        !          5124: /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
        !          5125:    of a structure component, returning a FIELD_DECL node.
        !          5126:    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
        !          5127: 
        !          5128:    This is done during the parsing of the struct declaration.
        !          5129:    The FIELD_DECL nodes are chained together and the lot of them
        !          5130:    are ultimately passed to `build_struct' to make the RECORD_TYPE node.  */
        !          5131: 
        !          5132: tree
        !          5133: grokfield (filename, line, declarator, declspecs, width)
        !          5134:      char *filename;
        !          5135:      int line;
        !          5136:      tree declarator, declspecs, width;
        !          5137: {
        !          5138:   tree value;
        !          5139: 
        !          5140:   /* The corresponding pop_obstacks is in finish_decl.  */
        !          5141:   push_obstacks_nochange ();
        !          5142: 
        !          5143:   value = grokdeclarator (declarator, declspecs, width ? BITFIELD : FIELD, 0);
        !          5144: 
        !          5145:   finish_decl (value, NULL_TREE, NULL_TREE);
        !          5146:   DECL_INITIAL (value) = width;
        !          5147: 
        !          5148:   maybe_objc_check_decl (value);
        !          5149:   return value;
        !          5150: }
        !          5151: 
        !          5152: /* Function to help qsort sort FIELD_DECLs by name order.  */
        !          5153: 
        !          5154: static int
        !          5155: field_decl_cmp (x, y)
        !          5156:      tree *x, *y;
        !          5157: {
        !          5158:   return (long)DECL_NAME (*x) - (long)DECL_NAME (*y);
        !          5159: }
        !          5160: 
        !          5161: /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
        !          5162:    FIELDLIST is a chain of FIELD_DECL nodes for the fields.
        !          5163: 
        !          5164:    We also do a pop_obstacks to match the push in start_struct.  */
        !          5165: 
        !          5166: tree
        !          5167: finish_struct (t, fieldlist)
        !          5168:      register tree t, fieldlist;
        !          5169: {
        !          5170:   register tree x;
        !          5171:   int old_momentary;
        !          5172:   int toplevel = global_binding_level == current_binding_level;
        !          5173: 
        !          5174:   /* If this type was previously laid out as a forward reference,
        !          5175:      make sure we lay it out again.  */
        !          5176: 
        !          5177:   TYPE_SIZE (t) = 0;
        !          5178: 
        !          5179:   /* Nameless union parm types are useful as GCC extension.  */
        !          5180:   if (! (TREE_CODE (t) == UNION_TYPE && TYPE_NAME (t) == 0) && !pedantic)
        !          5181:     /* Otherwise, warn about any struct or union def. in parmlist.  */
        !          5182:     if (in_parm_level_p ())
        !          5183:       {
        !          5184:        if (pedantic)
        !          5185:          pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
        !          5186:                    : "structure defined inside parms"));
        !          5187:        else if (! flag_traditional)
        !          5188:          warning ((TREE_CODE (t) == UNION_TYPE ? "union defined inside parms"
        !          5189:                    : "structure defined inside parms"));
        !          5190:       }
        !          5191: 
        !          5192:   old_momentary = suspend_momentary ();
        !          5193: 
        !          5194:   if (fieldlist == 0 && pedantic)
        !          5195:     pedwarn ((TREE_CODE (t) == UNION_TYPE ? "union has no members"
        !          5196:              : "structure has no members"));
        !          5197: 
        !          5198:   /* Install struct as DECL_CONTEXT of each field decl.
        !          5199:      Also process specified field sizes.
        !          5200:      Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
        !          5201:      The specified size is found in the DECL_INITIAL.
        !          5202:      Store 0 there, except for ": 0" fields (so we can find them
        !          5203:      and delete them, below).  */
        !          5204: 
        !          5205:   for (x = fieldlist; x; x = TREE_CHAIN (x))
        !          5206:     {
        !          5207:       DECL_CONTEXT (x) = t;
        !          5208:       DECL_FIELD_SIZE (x) = 0;
        !          5209: 
        !          5210:       /* If any field is const, the structure type is pseudo-const.  */
        !          5211:       if (TREE_READONLY (x))
        !          5212:        C_TYPE_FIELDS_READONLY (t) = 1;
        !          5213:       else
        !          5214:        {
        !          5215:          /* A field that is pseudo-const makes the structure likewise.  */
        !          5216:          tree t1 = TREE_TYPE (x);
        !          5217:          while (TREE_CODE (t1) == ARRAY_TYPE)
        !          5218:            t1 = TREE_TYPE (t1);
        !          5219:          if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
        !          5220:              && C_TYPE_FIELDS_READONLY (t1))
        !          5221:            C_TYPE_FIELDS_READONLY (t) = 1;
        !          5222:        }
        !          5223: 
        !          5224:       /* Any field that is volatile means variables of this type must be
        !          5225:         treated in some ways as volatile.  */
        !          5226:       if (TREE_THIS_VOLATILE (x))
        !          5227:        C_TYPE_FIELDS_VOLATILE (t) = 1;
        !          5228: 
        !          5229:       /* Any field of nominal variable size implies structure is too.  */
        !          5230:       if (C_DECL_VARIABLE_SIZE (x))
        !          5231:        C_TYPE_VARIABLE_SIZE (t) = 1;
        !          5232: 
        !          5233:       /* Detect invalid nested redefinition.  */
        !          5234:       if (TREE_TYPE (x) == t)
        !          5235:        error ("nested redefinition of `%s'",
        !          5236:               IDENTIFIER_POINTER (TYPE_NAME (t)));
        !          5237: 
        !          5238:       /* Detect invalid bit-field size.  */
        !          5239:       if (DECL_INITIAL (x))
        !          5240:        STRIP_NOPS (DECL_INITIAL (x));
        !          5241:       if (DECL_INITIAL (x))
        !          5242:        {
        !          5243:          if (TREE_CODE (DECL_INITIAL (x)) == INTEGER_CST)
        !          5244:            constant_expression_warning (DECL_INITIAL (x));
        !          5245:          else
        !          5246:            {
        !          5247:              error_with_decl (x, "bit-field `%s' width not an integer constant");
        !          5248:              DECL_INITIAL (x) = NULL;
        !          5249:            }
        !          5250:        }
        !          5251: 
        !          5252:       /* Detect invalid bit-field type.  */
        !          5253:       if (DECL_INITIAL (x)
        !          5254:          && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
        !          5255:          && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
        !          5256:        {
        !          5257:          error_with_decl (x, "bit-field `%s' has invalid type");
        !          5258:          DECL_INITIAL (x) = NULL;
        !          5259:        }
        !          5260:       if (DECL_INITIAL (x) && pedantic
        !          5261:          && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != integer_type_node
        !          5262:          && TYPE_MAIN_VARIANT (TREE_TYPE (x)) != unsigned_type_node
        !          5263:          /* Accept an enum that's equivalent to int or unsigned int.  */
        !          5264:          && !(TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
        !          5265:               && (TYPE_PRECISION (TREE_TYPE (x))
        !          5266:                   == TYPE_PRECISION (integer_type_node))))
        !          5267:        pedwarn_with_decl (x, "bit-field `%s' type invalid in ANSI C");
        !          5268: 
        !          5269:       /* Detect and ignore out of range field width.  */
        !          5270:       if (DECL_INITIAL (x))
        !          5271:        {
        !          5272:          unsigned HOST_WIDE_INT width = TREE_INT_CST_LOW (DECL_INITIAL (x));
        !          5273: 
        !          5274:          if (tree_int_cst_lt (DECL_INITIAL (x), integer_zero_node))
        !          5275:            {
        !          5276:              DECL_INITIAL (x) = NULL;
        !          5277:              error_with_decl (x, "negative width in bit-field `%s'");
        !          5278:            }
        !          5279:          else if (TREE_INT_CST_HIGH (DECL_INITIAL (x)) != 0
        !          5280:                   || width > TYPE_PRECISION (TREE_TYPE (x)))
        !          5281:            {
        !          5282:              DECL_INITIAL (x) = NULL;
        !          5283:              pedwarn_with_decl (x, "width of `%s' exceeds its type");
        !          5284:            }
        !          5285:          else if (width == 0 && DECL_NAME (x) != 0)
        !          5286:            {
        !          5287:              error_with_decl (x, "zero width for bit-field `%s'");
        !          5288:              DECL_INITIAL (x) = NULL;
        !          5289:            }
        !          5290:        }
        !          5291: 
        !          5292:       /* Process valid field width.  */
        !          5293:       if (DECL_INITIAL (x))
        !          5294:        {
        !          5295:          register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
        !          5296: 
        !          5297:          DECL_FIELD_SIZE (x) = width;
        !          5298:          DECL_BIT_FIELD (x) = 1;
        !          5299:          DECL_INITIAL (x) = NULL;
        !          5300: 
        !          5301:          if (width == 0)
        !          5302:            {
        !          5303:              /* field size 0 => force desired amount of alignment.  */
        !          5304: #ifdef EMPTY_FIELD_BOUNDARY
        !          5305:              DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
        !          5306: #endif
        !          5307: #ifdef PCC_BITFIELD_TYPE_MATTERS
        !          5308:              DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
        !          5309:                                    TYPE_ALIGN (TREE_TYPE (x)));
        !          5310: #endif
        !          5311:            }
        !          5312:        }
        !          5313:       else
        !          5314:        {
        !          5315:          int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT
        !          5316:                           : TYPE_ALIGN (TREE_TYPE (x)));
        !          5317:          /* Non-bit-fields are aligned for their type, except packed
        !          5318:             fields which require only BITS_PER_UNIT alignment.  */
        !          5319:          DECL_ALIGN (x) = MAX (DECL_ALIGN (x), min_align);
        !          5320:        }
        !          5321:     }
        !          5322: 
        !          5323:   /* Now DECL_INITIAL is null on all members.  */
        !          5324: 
        !          5325:   /* Delete all duplicate fields from the fieldlist */
        !          5326:   for (x = fieldlist; x && TREE_CHAIN (x);)
        !          5327:     /* Anonymous fields aren't duplicates.  */
        !          5328:     if (DECL_NAME (TREE_CHAIN (x)) == 0)
        !          5329:       x = TREE_CHAIN (x);
        !          5330:     else
        !          5331:       {
        !          5332:        register tree y = fieldlist;
        !          5333:          
        !          5334:        while (1)
        !          5335:          {
        !          5336:            if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
        !          5337:              break;
        !          5338:            if (y == x)
        !          5339:              break;
        !          5340:            y = TREE_CHAIN (y);
        !          5341:          }
        !          5342:        if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
        !          5343:          {
        !          5344:            error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
        !          5345:            TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
        !          5346:          }
        !          5347:        else x = TREE_CHAIN (x);
        !          5348:       }
        !          5349: 
        !          5350:   /* Now we have the nearly final fieldlist.  Record it,
        !          5351:      then lay out the structure or union (including the fields).  */
        !          5352: 
        !          5353:   TYPE_FIELDS (t) = fieldlist;
        !          5354: 
        !          5355:   layout_type (t);
        !          5356: 
        !          5357:   /* Delete all zero-width bit-fields from the front of the fieldlist */
        !          5358:   while (fieldlist
        !          5359:         && DECL_INITIAL (fieldlist))
        !          5360:     fieldlist = TREE_CHAIN (fieldlist);
        !          5361:   /* Delete all such members from the rest of the fieldlist */
        !          5362:   for (x = fieldlist; x;)
        !          5363:     {
        !          5364:       if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
        !          5365:        TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
        !          5366:       else x = TREE_CHAIN (x);
        !          5367:     }
        !          5368: 
        !          5369:   /*  Now we have the truly final field list.
        !          5370:       Store it in this type and in the variants.  */
        !          5371: 
        !          5372:   TYPE_FIELDS (t) = fieldlist;
        !          5373: 
        !          5374:   /* If there are lots of fields, sort so we can look through them fast.
        !          5375:      We arbitrarily consider 16 or more elts to be "a lot".  */
        !          5376:   {
        !          5377:     int len = 0;
        !          5378: 
        !          5379:     for (x = fieldlist; x; x = TREE_CHAIN (x))
        !          5380:       {
        !          5381:        if (len > 15)
        !          5382:          break;
        !          5383:        len += 1;
        !          5384:       }
        !          5385:     if (len > 15)
        !          5386:       {
        !          5387:        tree *field_array;
        !          5388:        char *space;
        !          5389: 
        !          5390:        len += list_length (x);
        !          5391:        /* Use the same allocation policy here that make_node uses, to
        !          5392:           ensure that this lives as long as the rest of the struct decl.
        !          5393:           All decls in an inline function need to be saved.  */
        !          5394:        if (allocation_temporary_p ())
        !          5395:          space = savealloc (sizeof (struct lang_type) + len * sizeof (tree));
        !          5396:        else
        !          5397:          space = oballoc (sizeof (struct lang_type) + len * sizeof (tree));
        !          5398: 
        !          5399:        TYPE_LANG_SPECIFIC (t) = (struct lang_type *) space;
        !          5400:        TYPE_LANG_SPECIFIC (t)->len = len;
        !          5401: 
        !          5402:        field_array = &TYPE_LANG_SPECIFIC (t)->elts[0];
        !          5403:        len = 0;
        !          5404:        for (x = fieldlist; x; x = TREE_CHAIN (x))
        !          5405:          field_array[len++] = x;
        !          5406: 
        !          5407:        qsort (field_array, len, sizeof (tree), field_decl_cmp);
        !          5408:       }
        !          5409:   }
        !          5410: 
        !          5411:   for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
        !          5412:     {
        !          5413:       TYPE_FIELDS (x) = TYPE_FIELDS (t);
        !          5414:       TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
        !          5415:       TYPE_ALIGN (x) = TYPE_ALIGN (t);
        !          5416:     }
        !          5417: 
        !          5418:   /* Promote each bit-field's type to int if it is narrower than that.  */
        !          5419:   for (x = fieldlist; x; x = TREE_CHAIN (x))
        !          5420:     if (DECL_BIT_FIELD (x)
        !          5421:        && (C_PROMOTING_INTEGER_TYPE_P (TREE_TYPE (x))
        !          5422:            || DECL_FIELD_SIZE (x) < TYPE_PRECISION (integer_type_node)))
        !          5423:       {
        !          5424:        tree type = TREE_TYPE (x);
        !          5425: 
        !          5426:        /* Preserve unsignedness if traditional
        !          5427:           or if not really getting any wider.  */
        !          5428:        if (TREE_UNSIGNED (type)
        !          5429:            && (flag_traditional
        !          5430:                ||
        !          5431:                (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
        !          5432:                 &&
        !          5433:                 DECL_FIELD_SIZE (x) == TYPE_PRECISION (integer_type_node))))
        !          5434:          TREE_TYPE (x) = unsigned_type_node;
        !          5435:        else
        !          5436:          TREE_TYPE (x) = integer_type_node;
        !          5437:       }
        !          5438: 
        !          5439:   /* If this structure or union completes the type of any previous
        !          5440:      variable declaration, lay it out and output its rtl.  */
        !          5441: 
        !          5442:   if (current_binding_level->n_incomplete != 0)
        !          5443:     {
        !          5444:       tree decl;
        !          5445:       for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
        !          5446:        {
        !          5447:          if (TREE_TYPE (decl) == t
        !          5448:              && TREE_CODE (decl) != TYPE_DECL)
        !          5449:            {
        !          5450:              layout_decl (decl, 0);
        !          5451:              /* This is a no-op in c-lang.c or something real in objc-actions.c.  */
        !          5452:              maybe_objc_check_decl (decl);
        !          5453:              rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
        !          5454:              if (! toplevel)
        !          5455:                expand_decl (decl);
        !          5456:              --current_binding_level->n_incomplete;
        !          5457:            }
        !          5458:          else if (TYPE_SIZE (TREE_TYPE (decl)) == 0
        !          5459:                   && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
        !          5460:            {
        !          5461:              tree element = TREE_TYPE (decl);
        !          5462:              while (TREE_CODE (element) == ARRAY_TYPE)
        !          5463:                element = TREE_TYPE (element);
        !          5464:              if (element == t)
        !          5465:                layout_array_type (TREE_TYPE (decl));
        !          5466:            }
        !          5467:        }
        !          5468:     }
        !          5469: 
        !          5470:   resume_momentary (old_momentary);
        !          5471: 
        !          5472:   /* Finish debugging output for this type.  */
        !          5473:   rest_of_type_compilation (t, toplevel);
        !          5474: 
        !          5475:   /* The matching push is in start_struct.  */
        !          5476:   pop_obstacks ();
        !          5477: 
        !          5478:   return t;
        !          5479: }
        !          5480: 
        !          5481: /* Lay out the type T, and its element type, and so on.  */
        !          5482: 
        !          5483: static void
        !          5484: layout_array_type (t)
        !          5485:      tree t;
        !          5486: {
        !          5487:   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
        !          5488:     layout_array_type (TREE_TYPE (t));
        !          5489:   layout_type (t);
        !          5490: }
        !          5491: 
        !          5492: /* Begin compiling the definition of an enumeration type.
        !          5493:    NAME is its name (or null if anonymous).
        !          5494:    Returns the type object, as yet incomplete.
        !          5495:    Also records info about it so that build_enumerator
        !          5496:    may be used to declare the individual values as they are read.  */
        !          5497: 
        !          5498: tree
        !          5499: start_enum (name)
        !          5500:      tree name;
        !          5501: {
        !          5502:   register tree enumtype = 0;
        !          5503: 
        !          5504:   /* If this is the real definition for a previous forward reference,
        !          5505:      fill in the contents in the same object that used to be the
        !          5506:      forward reference.  */
        !          5507: 
        !          5508:   if (name != 0)
        !          5509:     enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
        !          5510: 
        !          5511:   /* The corresponding pop_obstacks is in finish_enum.  */
        !          5512:   push_obstacks_nochange ();
        !          5513:   /* If these symbols and types are global, make them permanent.  */
        !          5514:   if (current_binding_level == global_binding_level)
        !          5515:     end_temporary_allocation ();
        !          5516: 
        !          5517:   if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
        !          5518:     {
        !          5519:       enumtype = make_node (ENUMERAL_TYPE);
        !          5520:       pushtag (name, enumtype);
        !          5521:     }
        !          5522: 
        !          5523:   C_TYPE_BEING_DEFINED (enumtype) = 1;
        !          5524: 
        !          5525:   if (TYPE_VALUES (enumtype) != 0)
        !          5526:     {
        !          5527:       /* This enum is a named one that has been declared already.  */
        !          5528:       error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
        !          5529: 
        !          5530:       /* Completely replace its old definition.
        !          5531:         The old enumerators remain defined, however.  */
        !          5532:       TYPE_VALUES (enumtype) = 0;
        !          5533:     }
        !          5534: 
        !          5535:   enum_next_value = integer_zero_node;
        !          5536:   enum_overflow = 0;
        !          5537: 
        !          5538:   return enumtype;
        !          5539: }
        !          5540: 
        !          5541: /* After processing and defining all the values of an enumeration type,
        !          5542:    install their decls in the enumeration type and finish it off.
        !          5543:    ENUMTYPE is the type object and VALUES a list of decl-value pairs.
        !          5544:    Returns ENUMTYPE.  */
        !          5545: 
        !          5546: tree
        !          5547: finish_enum (enumtype, values)
        !          5548:      register tree enumtype, values;
        !          5549: {
        !          5550:   register tree pair, tem;
        !          5551:   tree minnode = 0, maxnode = 0;
        !          5552:   register HOST_WIDE_INT maxvalue = 0;
        !          5553:   register HOST_WIDE_INT minvalue = 0;
        !          5554:   register int i;
        !          5555:   unsigned precision = 0;
        !          5556:   int toplevel = global_binding_level == current_binding_level;
        !          5557:   int temporary = allocation_temporary_p ();
        !          5558: 
        !          5559:   if (in_parm_level_p ())
        !          5560:     warning ("enum defined inside parms");
        !          5561: 
        !          5562:   /* Calculate the maximum value of any enumerator in this type.  */
        !          5563: 
        !          5564:   for (pair = values; pair; pair = TREE_CHAIN (pair))
        !          5565:     {
        !          5566:       tree value = TREE_VALUE (pair);
        !          5567:       if (pair == values)
        !          5568:        minnode = maxnode = TREE_VALUE (pair);
        !          5569:       else
        !          5570:        {
        !          5571:          if (tree_int_cst_lt (maxnode, value))
        !          5572:            maxnode = value;
        !          5573:          if (tree_int_cst_lt (value, minnode))
        !          5574:            minnode = value;
        !          5575:        }
        !          5576:     }
        !          5577: 
        !          5578:   TYPE_MIN_VALUE (enumtype) = minnode;
        !          5579:   TYPE_MAX_VALUE (enumtype) = maxnode;
        !          5580: 
        !          5581:   /* Determine the precision this type needs.  */
        !          5582: 
        !          5583:   if (TREE_INT_CST_HIGH (minnode) >= 0
        !          5584:       ? tree_int_cst_lt (TYPE_MAX_VALUE (unsigned_type_node), maxnode)
        !          5585:       : (tree_int_cst_lt (minnode, TYPE_MIN_VALUE (integer_type_node))
        !          5586:         || tree_int_cst_lt (TYPE_MAX_VALUE (integer_type_node), maxnode)))
        !          5587:     precision = TYPE_PRECISION (long_long_integer_type_node);
        !          5588:   else
        !          5589:     {
        !          5590:       maxvalue = TREE_INT_CST_LOW (maxnode);
        !          5591:       minvalue = TREE_INT_CST_LOW (minnode);
        !          5592: 
        !          5593:       if (maxvalue > 0)
        !          5594:        precision = floor_log2 (maxvalue) + 1;
        !          5595:       if (minvalue < 0)
        !          5596:        {
        !          5597:          /* Compute number of bits to represent magnitude of a negative value.
        !          5598:             Add one to MINVALUE since range of negative numbers
        !          5599:             includes the power of two.  */
        !          5600:          unsigned negprecision = floor_log2 (-minvalue - 1) + 1;
        !          5601:          if (negprecision > precision)
        !          5602:            precision = negprecision;
        !          5603:          precision += 1;       /* room for sign bit */
        !          5604:        }
        !          5605: 
        !          5606:       if (!precision)
        !          5607:        precision = 1;
        !          5608:     }
        !          5609: 
        !          5610:   if (flag_short_enums || precision > TYPE_PRECISION (integer_type_node))
        !          5611:     /* Use the width of the narrowest normal C type which is wide enough.  */
        !          5612:     TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size (precision, 1));
        !          5613:   else
        !          5614:     TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
        !          5615: 
        !          5616:   TYPE_SIZE (enumtype) = 0;
        !          5617:   layout_type (enumtype);
        !          5618: 
        !          5619:   /* An enum can have some negative values; then it is signed.  */
        !          5620:   TREE_UNSIGNED (enumtype) = ! tree_int_cst_lt (minnode, integer_zero_node);
        !          5621: 
        !          5622:   /* Change the type of the enumerators to be the enum type.
        !          5623:      Formerly this was done only for enums that fit in an int,
        !          5624:      but the comment said it was done only for enums wider than int.
        !          5625:      It seems necessary to do this for wide enums,
        !          5626:      and best not to change what's done for ordinary narrower ones.  */
        !          5627:   for (pair = values; pair; pair = TREE_CHAIN (pair))
        !          5628:     {
        !          5629:       TREE_TYPE (TREE_PURPOSE (pair)) = enumtype;
        !          5630:       DECL_SIZE (TREE_PURPOSE (pair)) = TYPE_SIZE (enumtype);
        !          5631:       if (TREE_CODE (TREE_PURPOSE (pair)) != FUNCTION_DECL)
        !          5632:        DECL_ALIGN (TREE_PURPOSE (pair)) = TYPE_ALIGN (enumtype);
        !          5633:     }
        !          5634: 
        !          5635:   /* Replace the decl nodes in VALUES with their names.  */
        !          5636:   for (pair = values; pair; pair = TREE_CHAIN (pair))
        !          5637:     TREE_PURPOSE (pair) = DECL_NAME (TREE_PURPOSE (pair));
        !          5638: 
        !          5639:   TYPE_VALUES (enumtype) = values;
        !          5640: 
        !          5641:   /* Fix up all variant types of this enum type.  */
        !          5642:   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
        !          5643:     {
        !          5644:       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
        !          5645:       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
        !          5646:       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
        !          5647:       TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
        !          5648:       TYPE_MODE (tem) = TYPE_MODE (enumtype);
        !          5649:       TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
        !          5650:       TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
        !          5651:       TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
        !          5652:     }
        !          5653: 
        !          5654:   /* Finish debugging output for this type.  */
        !          5655:   rest_of_type_compilation (enumtype, toplevel);
        !          5656: 
        !          5657:   /* This matches a push in start_enum.  */
        !          5658:   pop_obstacks ();
        !          5659: 
        !          5660:   return enumtype;
        !          5661: }
        !          5662: 
        !          5663: /* Build and install a CONST_DECL for one value of the
        !          5664:    current enumeration type (one that was begun with start_enum).
        !          5665:    Return a tree-list containing the CONST_DECL and its value.
        !          5666:    Assignment of sequential values by default is handled here.  */
        !          5667: 
        !          5668: tree
        !          5669: build_enumerator (name, value)
        !          5670:      tree name, value;
        !          5671: {
        !          5672:   register tree decl, type;
        !          5673: 
        !          5674:   /* Validate and default VALUE.  */
        !          5675: 
        !          5676:   /* Remove no-op casts from the value.  */
        !          5677:   if (value)
        !          5678:     STRIP_TYPE_NOPS (value);
        !          5679: 
        !          5680:   if (value != 0)
        !          5681:     {
        !          5682:       if (TREE_CODE (value) == INTEGER_CST)
        !          5683:        {
        !          5684:          value = default_conversion (value);
        !          5685:          constant_expression_warning (value);
        !          5686:        }
        !          5687:       else
        !          5688:        {
        !          5689:          error ("enumerator value for `%s' not integer constant",
        !          5690:                 IDENTIFIER_POINTER (name));
        !          5691:          value = 0;
        !          5692:        }
        !          5693:     }
        !          5694: 
        !          5695:   /* Default based on previous value.  */
        !          5696:   /* It should no longer be possible to have NON_LVALUE_EXPR
        !          5697:      in the default.  */
        !          5698:   if (value == 0)
        !          5699:     {
        !          5700:       value = enum_next_value;
        !          5701:       if (enum_overflow)
        !          5702:        error ("overflow in enumeration values");
        !          5703:     }
        !          5704: 
        !          5705:   if (pedantic && ! int_fits_type_p (value, integer_type_node))
        !          5706:     {
        !          5707:       pedwarn ("ANSI C restricts enumerator values to range of `int'");
        !          5708:       value = integer_zero_node;
        !          5709:     }
        !          5710: 
        !          5711:   /* Set basis for default for next value.  */
        !          5712:   enum_next_value = build_binary_op (PLUS_EXPR, value, integer_one_node, 0);
        !          5713:   enum_overflow = tree_int_cst_lt (enum_next_value, value);
        !          5714: 
        !          5715:   /* Now create a declaration for the enum value name.  */
        !          5716: 
        !          5717:   type = TREE_TYPE (value);
        !          5718:   type = type_for_size (MAX (TYPE_PRECISION (type),
        !          5719:                             TYPE_PRECISION (integer_type_node)),
        !          5720:                        ((flag_traditional
        !          5721:                          || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
        !          5722:                         && TREE_UNSIGNED (type)));
        !          5723: 
        !          5724:   decl = build_decl (CONST_DECL, name, type);
        !          5725:   DECL_INITIAL (decl) = value;
        !          5726:   TREE_TYPE (value) = type;
        !          5727:   pushdecl (decl);
        !          5728: 
        !          5729:   return saveable_tree_cons (decl, value, NULL_TREE);
        !          5730: }
        !          5731: 
        !          5732: /* Create the FUNCTION_DECL for a function definition.
        !          5733:    DECLSPECS and DECLARATOR are the parts of the declaration;
        !          5734:    they describe the function's name and the type it returns,
        !          5735:    but twisted together in a fashion that parallels the syntax of C.
        !          5736: 
        !          5737:    This function creates a binding context for the function body
        !          5738:    as well as setting up the FUNCTION_DECL in current_function_decl.
        !          5739: 
        !          5740:    Returns 1 on success.  If the DECLARATOR is not suitable for a function
        !          5741:    (it defines a datum instead), we return 0, which tells
        !          5742:    yyparse to report a parse error.
        !          5743: 
        !          5744:    NESTED is nonzero for a function nested within another function.  */
        !          5745: 
        !          5746: int
        !          5747: start_function (declspecs, declarator, nested)
        !          5748:      tree declarator, declspecs;
        !          5749:      int nested;
        !          5750: {
        !          5751:   tree decl1, old_decl;
        !          5752:   tree restype;
        !          5753: 
        !          5754:   current_function_returns_value = 0;  /* Assume, until we see it does. */
        !          5755:   current_function_returns_null = 0;
        !          5756:   warn_about_return_type = 0;
        !          5757:   current_extern_inline = 0;
        !          5758:   c_function_varargs = 0;
        !          5759:   named_labels = 0;
        !          5760:   shadowed_labels = 0;
        !          5761: 
        !          5762:   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
        !          5763: 
        !          5764:   /* If the declarator is not suitable for a function definition,
        !          5765:      cause a syntax error.  */
        !          5766:   if (decl1 == 0)
        !          5767:     return 0;
        !          5768: 
        !          5769:   announce_function (decl1);
        !          5770: 
        !          5771:   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
        !          5772:     {
        !          5773:       error ("return-type is an incomplete type");
        !          5774:       /* Make it return void instead.  */
        !          5775:       TREE_TYPE (decl1)
        !          5776:        = build_function_type (void_type_node,
        !          5777:                               TYPE_ARG_TYPES (TREE_TYPE (decl1)));
        !          5778:     }
        !          5779: 
        !          5780:   if (warn_about_return_type)
        !          5781:     warning ("return-type defaults to `int'");
        !          5782: 
        !          5783:   /* Save the parm names or decls from this function's declarator
        !          5784:      where store_parm_decls will find them.  */
        !          5785:   current_function_parms = last_function_parms;
        !          5786:   current_function_parm_tags = last_function_parm_tags;
        !          5787: 
        !          5788:   /* Make the init_value nonzero so pushdecl knows this is not tentative.
        !          5789:      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
        !          5790:   DECL_INITIAL (decl1) = error_mark_node;
        !          5791: 
        !          5792:   /* If this definition isn't a prototype and we had a prototype declaration
        !          5793:      before, copy the arg type info from that prototype.
        !          5794:      But not if what we had before was a builtin function.  */
        !          5795:   old_decl = lookup_name_current_level (DECL_NAME (decl1));
        !          5796:   if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
        !          5797:       && !DECL_BUILT_IN (old_decl)
        !          5798:       && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
        !          5799:          == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (old_decl))))
        !          5800:       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0)
        !          5801:     {
        !          5802:       TREE_TYPE (decl1) = TREE_TYPE (old_decl);
        !          5803:       current_function_prototype_file = DECL_SOURCE_FILE (old_decl);
        !          5804:       current_function_prototype_line = DECL_SOURCE_LINE (old_decl);
        !          5805:     }
        !          5806: 
        !          5807:   /* Optionally warn of old-fashioned def with no previous prototype.  */
        !          5808:   if (warn_strict_prototypes
        !          5809:       && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
        !          5810:       && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
        !          5811:     warning ("function declaration isn't a prototype");
        !          5812:   /* Optionally warn of any global def with no previous prototype.  */
        !          5813:   else if (warn_missing_prototypes
        !          5814:           && TREE_PUBLIC (decl1)
        !          5815:           && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)
        !          5816:           && strcmp ("main", IDENTIFIER_POINTER (DECL_NAME (decl1))))
        !          5817:     warning_with_decl (decl1, "no previous prototype for `%s'");
        !          5818:   /* Optionally warn of any def with no previous prototype
        !          5819:      if the function has already been used.  */
        !          5820:   else if (warn_missing_prototypes
        !          5821:           && old_decl != 0 && TREE_USED (old_decl)
        !          5822:           && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0))
        !          5823:     warning_with_decl (decl1, "`%s' was used with no prototype before its definition");
        !          5824: 
        !          5825:   /* This is a definition, not a reference.
        !          5826:      So normally clear DECL_EXTERNAL.
        !          5827:      However, `extern inline' acts like a declaration
        !          5828:      except for defining how to inline.  So set DECL_EXTERNAL in that case.  */
        !          5829:   DECL_EXTERNAL (decl1) = current_extern_inline;
        !          5830: 
        !          5831:   /* This function exists in static storage.
        !          5832:      (This does not mean `static' in the C sense!)  */
        !          5833:   TREE_STATIC (decl1) = 1;
        !          5834: 
        !          5835:   /* A nested function is not global.  */
        !          5836:   if (current_function_decl != 0)
        !          5837:     TREE_PUBLIC (decl1) = 0;
        !          5838: 
        !          5839:   /* Record the decl so that the function name is defined.
        !          5840:      If we already have a decl for this name, and it is a FUNCTION_DECL,
        !          5841:      use the old decl.  */
        !          5842: 
        !          5843:   current_function_decl = pushdecl (decl1);
        !          5844: 
        !          5845:   pushlevel (0);
        !          5846:   declare_parm_level (1);
        !          5847:   current_binding_level->subblocks_tag_transparent = 1;
        !          5848: 
        !          5849:   make_function_rtl (current_function_decl);
        !          5850: 
        !          5851:   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
        !          5852:   /* Promote the value to int before returning it.  */
        !          5853:   if (C_PROMOTING_INTEGER_TYPE_P (restype))
        !          5854:     {
        !          5855:       /* It retains unsignedness if traditional
        !          5856:         or if not really getting wider.  */
        !          5857:       if (TREE_UNSIGNED (restype)
        !          5858:          && (flag_traditional
        !          5859:              || (TYPE_PRECISION (restype)
        !          5860:                  == TYPE_PRECISION (integer_type_node))))
        !          5861:        restype = unsigned_type_node;
        !          5862:       else
        !          5863:        restype = integer_type_node;
        !          5864:     }
        !          5865:   DECL_RESULT (current_function_decl)
        !          5866:     = build_decl (RESULT_DECL, NULL_TREE, restype);
        !          5867: 
        !          5868:   if (!nested)
        !          5869:     /* Allocate further tree nodes temporarily during compilation
        !          5870:        of this function only.  */
        !          5871:     temporary_allocation ();
        !          5872: 
        !          5873:   /* If this fcn was already referenced via a block-scope `extern' decl
        !          5874:      (or an implicit decl), propagate certain information about the usage.  */
        !          5875:   if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
        !          5876:     TREE_ADDRESSABLE (current_function_decl) = 1;
        !          5877: 
        !          5878:   return 1;
        !          5879: }
        !          5880: 
        !          5881: /* Record that this function is going to be a varargs function.
        !          5882:    This is called before store_parm_decls, which is too early
        !          5883:    to call mark_varargs directly.  */
        !          5884: 
        !          5885: void
        !          5886: c_mark_varargs ()
        !          5887: {
        !          5888:   c_function_varargs = 1;
        !          5889: }
        !          5890: 
        !          5891: /* Store the parameter declarations into the current function declaration.
        !          5892:    This is called after parsing the parameter declarations, before
        !          5893:    digesting the body of the function.
        !          5894: 
        !          5895:    For an old-style definition, modify the function's type
        !          5896:    to specify at least the number of arguments.  */
        !          5897: 
        !          5898: void
        !          5899: store_parm_decls ()
        !          5900: {
        !          5901:   register tree fndecl = current_function_decl;
        !          5902:   register tree parm;
        !          5903: 
        !          5904:   /* This is either a chain of PARM_DECLs (if a prototype was used)
        !          5905:      or a list of IDENTIFIER_NODEs (for an old-fashioned C definition).  */
        !          5906:   tree specparms = current_function_parms;
        !          5907: 
        !          5908:   /* This is a list of types declared among parms in a prototype.  */
        !          5909:   tree parmtags = current_function_parm_tags;
        !          5910: 
        !          5911:   /* This is a chain of PARM_DECLs from old-style parm declarations.  */
        !          5912:   register tree parmdecls = getdecls ();
        !          5913: 
        !          5914:   /* This is a chain of any other decls that came in among the parm
        !          5915:      declarations.  If a parm is declared with  enum {foo, bar} x;
        !          5916:      then CONST_DECLs for foo and bar are put here.  */
        !          5917:   tree nonparms = 0;
        !          5918: 
        !          5919:   /* Nonzero if this definition is written with a prototype.  */
        !          5920:   int prototype = 0;
        !          5921: 
        !          5922:   if (specparms != 0 && TREE_CODE (specparms) != TREE_LIST)
        !          5923:     {
        !          5924:       /* This case is when the function was defined with an ANSI prototype.
        !          5925:         The parms already have decls, so we need not do anything here
        !          5926:         except record them as in effect
        !          5927:         and complain if any redundant old-style parm decls were written.  */
        !          5928: 
        !          5929:       register tree next;
        !          5930:       tree others = 0;
        !          5931: 
        !          5932:       prototype = 1;
        !          5933: 
        !          5934:       if (parmdecls != 0)
        !          5935:        {
        !          5936:          tree decl, link;
        !          5937: 
        !          5938:          error_with_decl (fndecl,
        !          5939:                           "parm types given both in parmlist and separately");
        !          5940:          /* Get rid of the erroneous decls; don't keep them on
        !          5941:             the list of parms, since they might not be PARM_DECLs.  */
        !          5942:          for (decl = current_binding_level->names;
        !          5943:               decl; decl = TREE_CHAIN (decl))
        !          5944:            if (DECL_NAME (decl))
        !          5945:              IDENTIFIER_LOCAL_VALUE (DECL_NAME (decl)) = 0;
        !          5946:          for (link = current_binding_level->shadowed;
        !          5947:               link; link = TREE_CHAIN (link))
        !          5948:            IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
        !          5949:          current_binding_level->names = 0;
        !          5950:          current_binding_level->shadowed = 0;
        !          5951:        }
        !          5952: 
        !          5953:       specparms = nreverse (specparms);
        !          5954:       for (parm = specparms; parm; parm = next)
        !          5955:        {
        !          5956:          next = TREE_CHAIN (parm);
        !          5957:          if (TREE_CODE (parm) == PARM_DECL)
        !          5958:            {
        !          5959:              if (DECL_NAME (parm) == 0)
        !          5960:                error_with_decl (parm, "parameter name omitted");
        !          5961:              else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
        !          5962:                {
        !          5963:                  error_with_decl (parm, "parameter `%s' declared void");
        !          5964:                  /* Change the type to error_mark_node so this parameter
        !          5965:                     will be ignored by assign_parms.  */
        !          5966:                  TREE_TYPE (parm) = error_mark_node;
        !          5967:                }
        !          5968:              pushdecl (parm);
        !          5969:            }
        !          5970:          else
        !          5971:            {
        !          5972:              /* If we find an enum constant or a type tag,
        !          5973:                 put it aside for the moment.  */
        !          5974:              TREE_CHAIN (parm) = 0;
        !          5975:              others = chainon (others, parm);
        !          5976:            }
        !          5977:        }
        !          5978: 
        !          5979:       /* Get the decls in their original chain order
        !          5980:         and record in the function.  */
        !          5981:       DECL_ARGUMENTS (fndecl) = getdecls ();
        !          5982: 
        !          5983: #if 0
        !          5984:       /* If this function takes a variable number of arguments,
        !          5985:         add a phony parameter to the end of the parm list,
        !          5986:         to represent the position of the first unnamed argument.  */
        !          5987:       if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
        !          5988:          != void_type_node)
        !          5989:        {
        !          5990:          tree dummy = build_decl (PARM_DECL, NULL_TREE, void_type_node);
        !          5991:          /* Let's hope the address of the unnamed parm
        !          5992:             won't depend on its type.  */
        !          5993:          TREE_TYPE (dummy) = integer_type_node;
        !          5994:          DECL_ARG_TYPE (dummy) = integer_type_node;
        !          5995:          DECL_ARGUMENTS (fndecl)
        !          5996:            = chainon (DECL_ARGUMENTS (fndecl), dummy);
        !          5997:        }
        !          5998: #endif
        !          5999: 
        !          6000:       /* Now pushdecl the enum constants.  */
        !          6001:       for (parm = others; parm; parm = next)
        !          6002:        {
        !          6003:          next = TREE_CHAIN (parm);
        !          6004:          if (DECL_NAME (parm) == 0)
        !          6005:            ;
        !          6006:          else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == void_type_node)
        !          6007:            ;
        !          6008:          else if (TREE_CODE (parm) != PARM_DECL)
        !          6009:            pushdecl (parm);
        !          6010:        }
        !          6011: 
        !          6012:       storetags (chainon (parmtags, gettags ()));
        !          6013:     }
        !          6014:   else
        !          6015:     {
        !          6016:       /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
        !          6017:         each with a parm name as the TREE_VALUE.
        !          6018: 
        !          6019:         PARMDECLS is a chain of declarations for parameters.
        !          6020:         Warning! It can also contain CONST_DECLs which are not parameters
        !          6021:         but are names of enumerators of any enum types
        !          6022:         declared among the parameters.
        !          6023: 
        !          6024:         First match each formal parameter name with its declaration.
        !          6025:         Associate decls with the names and store the decls
        !          6026:         into the TREE_PURPOSE slots.  */
        !          6027: 
        !          6028:       for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
        !          6029:        DECL_RESULT (parm) = 0;
        !          6030: 
        !          6031:       for (parm = specparms; parm; parm = TREE_CHAIN (parm))
        !          6032:        {
        !          6033:          register tree tail, found = NULL;
        !          6034: 
        !          6035:          if (TREE_VALUE (parm) == 0)
        !          6036:            {
        !          6037:              error_with_decl (fndecl, "parameter name missing from parameter list");
        !          6038:              TREE_PURPOSE (parm) = 0;
        !          6039:              continue;
        !          6040:            }
        !          6041: 
        !          6042:          /* See if any of the parmdecls specifies this parm by name.
        !          6043:             Ignore any enumerator decls.  */
        !          6044:          for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
        !          6045:            if (DECL_NAME (tail) == TREE_VALUE (parm)
        !          6046:                && TREE_CODE (tail) == PARM_DECL)
        !          6047:              {
        !          6048:                found = tail;
        !          6049:                break;
        !          6050:              }
        !          6051: 
        !          6052:          /* If declaration already marked, we have a duplicate name.
        !          6053:             Complain, and don't use this decl twice.   */
        !          6054:          if (found && DECL_RESULT (found) != 0)
        !          6055:            {
        !          6056:              error_with_decl (found, "multiple parameters named `%s'");
        !          6057:              found = 0;
        !          6058:            }
        !          6059: 
        !          6060:          /* If the declaration says "void", complain and ignore it.  */
        !          6061:          if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
        !          6062:            {
        !          6063:              error_with_decl (found, "parameter `%s' declared void");
        !          6064:              TREE_TYPE (found) = integer_type_node;
        !          6065:              DECL_ARG_TYPE (found) = integer_type_node;
        !          6066:              layout_decl (found, 0);
        !          6067:            }
        !          6068: 
        !          6069:          /* Traditionally, a parm declared float is actually a double.  */
        !          6070:          if (found && flag_traditional
        !          6071:              && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
        !          6072:            {
        !          6073:              TREE_TYPE (found) = double_type_node;
        !          6074:              DECL_ARG_TYPE (found) = double_type_node;
        !          6075:              layout_decl (found, 0);
        !          6076:            }
        !          6077: 
        !          6078:          /* If no declaration found, default to int.  */
        !          6079:          if (!found)
        !          6080:            {
        !          6081:              found = build_decl (PARM_DECL, TREE_VALUE (parm),
        !          6082:                                  integer_type_node);
        !          6083:              DECL_ARG_TYPE (found) = TREE_TYPE (found);
        !          6084:              DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
        !          6085:              DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
        !          6086:              if (extra_warnings)
        !          6087:                warning_with_decl (found, "type of `%s' defaults to `int'");
        !          6088:              pushdecl (found);
        !          6089:            }
        !          6090: 
        !          6091:          TREE_PURPOSE (parm) = found;
        !          6092: 
        !          6093:          /* Mark this decl as "already found" -- see test, above.
        !          6094:             It is safe to use DECL_RESULT for this
        !          6095:             since it is not used in PARM_DECLs or CONST_DECLs.  */
        !          6096:          DECL_RESULT (found) = error_mark_node;
        !          6097:        }
        !          6098: 
        !          6099:       /* Put anything which is on the parmdecls chain and which is
        !          6100:         not a PARM_DECL onto the list NONPARMS.  (The types of
        !          6101:         non-parm things which might appear on the list include
        !          6102:         enumerators and NULL-named TYPE_DECL nodes.) Complain about
        !          6103:         any actual PARM_DECLs not matched with any names.  */
        !          6104: 
        !          6105:       nonparms = 0;
        !          6106:       for (parm = parmdecls; parm; )
        !          6107:        {
        !          6108:          tree next = TREE_CHAIN (parm);
        !          6109:          TREE_CHAIN (parm) = 0;
        !          6110: 
        !          6111:          if (TREE_CODE (parm) != PARM_DECL)
        !          6112:            nonparms = chainon (nonparms, parm);
        !          6113:          else
        !          6114:            {
        !          6115:              /* Complain about args with incomplete types.  */
        !          6116:              if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
        !          6117:                {
        !          6118:                  error_with_decl (parm, "parameter `%s' has incomplete type");
        !          6119:                  TREE_TYPE (parm) = error_mark_node;
        !          6120:                }
        !          6121: 
        !          6122:              if (DECL_RESULT (parm) == 0)
        !          6123:                {
        !          6124:                  error_with_decl (parm,
        !          6125:                                   "declaration for parameter `%s' but no such parameter");
        !          6126:                  /* Pretend the parameter was not missing.
        !          6127:                     This gets us to a standard state and minimizes
        !          6128:                     further error messages.  */
        !          6129:                  specparms
        !          6130:                    = chainon (specparms,
        !          6131:                               tree_cons (parm, NULL_TREE, NULL_TREE));
        !          6132:                }
        !          6133:            }
        !          6134: 
        !          6135:          parm = next;
        !          6136:        }
        !          6137: 
        !          6138:       /* Chain the declarations together in the order of the list of names.  */
        !          6139:       /* Store that chain in the function decl, replacing the list of names.  */
        !          6140:       parm = specparms;
        !          6141:       DECL_ARGUMENTS (fndecl) = 0;
        !          6142:       {
        !          6143:        register tree last;
        !          6144:        for (last = 0; parm; parm = TREE_CHAIN (parm))
        !          6145:          if (TREE_PURPOSE (parm))
        !          6146:            {
        !          6147:              if (last == 0)
        !          6148:                DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
        !          6149:              else
        !          6150:                TREE_CHAIN (last) = TREE_PURPOSE (parm);
        !          6151:              last = TREE_PURPOSE (parm);
        !          6152:              TREE_CHAIN (last) = 0;
        !          6153:            }
        !          6154:       }
        !          6155: 
        !          6156:       /* If there was a previous prototype,
        !          6157:         set the DECL_ARG_TYPE of each argument according to
        !          6158:         the type previously specified, and report any mismatches.  */
        !          6159: 
        !          6160:       if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
        !          6161:        {
        !          6162:          register tree type;
        !          6163:          for (parm = DECL_ARGUMENTS (fndecl),
        !          6164:               type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
        !          6165:               parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type))
        !          6166:                                 != void_type_node));
        !          6167:               parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
        !          6168:            {
        !          6169:              if (parm == 0 || type == 0
        !          6170:                  || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
        !          6171:                {
        !          6172:                  error ("number of arguments doesn't match prototype");
        !          6173:                  error_with_file_and_line (current_function_prototype_file,
        !          6174:                                            current_function_prototype_line,
        !          6175:                                            "prototype declaration");
        !          6176:                  break;
        !          6177:                }
        !          6178:              /* Type for passing arg must be consistent
        !          6179:                 with that declared for the arg.  */
        !          6180:              if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
        !          6181:                {
        !          6182:                  if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
        !          6183:                      == TYPE_MAIN_VARIANT (TREE_VALUE (type)))
        !          6184:                    {
        !          6185:                      /* Adjust argument to match prototype.  E.g. a previous
        !          6186:                         `int foo(float);' prototype causes
        !          6187:                         `int foo(x) float x; {...}' to be treated like
        !          6188:                         `int foo(float x) {...}'.  This is particularly
        !          6189:                         useful for argument types like uid_t.  */
        !          6190:                      DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
        !          6191: #ifdef PROMOTE_PROTOTYPES
        !          6192:                      if ((TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
        !          6193:                           || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE)
        !          6194:                          && TYPE_PRECISION (TREE_TYPE (parm))
        !          6195:                          < TYPE_PRECISION (integer_type_node))
        !          6196:                        DECL_ARG_TYPE (parm) = integer_type_node;
        !          6197: #endif
        !          6198:                      if (pedantic)
        !          6199:                        {
        !          6200:                          pedwarn ("promoted argument `%s' doesn't match prototype",
        !          6201:                                   IDENTIFIER_POINTER (DECL_NAME (parm)));
        !          6202:                          warning_with_file_and_line
        !          6203:                            (current_function_prototype_file,
        !          6204:                             current_function_prototype_line,
        !          6205:                             "prototype declaration");
        !          6206:                        }
        !          6207:                    }
        !          6208:                  /* If -traditional, allow `int' argument to match
        !          6209:                     `unsigned' prototype.  */
        !          6210:                  else if (! (flag_traditional
        !          6211:                              && TYPE_MAIN_VARIANT (TREE_TYPE (parm)) == integer_type_node
        !          6212:                              && TYPE_MAIN_VARIANT (TREE_VALUE (type)) == unsigned_type_node))
        !          6213:                    {
        !          6214:                      error ("argument `%s' doesn't match prototype",
        !          6215:                             IDENTIFIER_POINTER (DECL_NAME (parm)));
        !          6216:                      error_with_file_and_line (current_function_prototype_file,
        !          6217:                                                current_function_prototype_line,
        !          6218:                                                "prototype declaration");
        !          6219:                    }
        !          6220:                }
        !          6221:            }
        !          6222:          TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = 0;
        !          6223:        }
        !          6224: 
        !          6225:       /* Otherwise, create a prototype that would match.  */
        !          6226: 
        !          6227:       else
        !          6228:        {
        !          6229:          register tree actual, type;
        !          6230:          register tree last = 0;
        !          6231: 
        !          6232:          for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
        !          6233:            {
        !          6234:              type = perm_tree_cons (NULL_TREE, DECL_ARG_TYPE (parm),
        !          6235:                                     NULL_TREE);
        !          6236:              if (last)
        !          6237:                TREE_CHAIN (last) = type;
        !          6238:              else
        !          6239:                actual = type;
        !          6240:              last = type;
        !          6241:            }
        !          6242:          type = perm_tree_cons (NULL_TREE, void_type_node, NULL_TREE);
        !          6243:          if (last)
        !          6244:            TREE_CHAIN (last) = type;
        !          6245:          else
        !          6246:            actual = type;
        !          6247: 
        !          6248:          /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
        !          6249:             of the type of this function, but we need to avoid having this
        !          6250:             affect the types of other similarly-typed functions, so we must
        !          6251:             first force the generation of an identical (but separate) type
        !          6252:             node for the relevant function type.  The new node we create
        !          6253:             will be a variant of the main variant of the original function
        !          6254:             type.  */
        !          6255: 
        !          6256:          TREE_TYPE (fndecl) = build_type_copy (TREE_TYPE (fndecl));
        !          6257: 
        !          6258:          TYPE_ACTUAL_ARG_TYPES (TREE_TYPE (fndecl)) = actual;
        !          6259:        }
        !          6260: 
        !          6261:       /* Now store the final chain of decls for the arguments
        !          6262:         as the decl-chain of the current lexical scope.
        !          6263:         Put the enumerators in as well, at the front so that
        !          6264:         DECL_ARGUMENTS is not modified.  */
        !          6265: 
        !          6266:       storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
        !          6267:     }
        !          6268: 
        !          6269:   /* Make sure the binding level for the top of the function body
        !          6270:      gets a BLOCK if there are any in the function.
        !          6271:      Otherwise, the dbx output is wrong.  */
        !          6272: 
        !          6273:   keep_next_if_subblocks = 1;
        !          6274: 
        !          6275:   /* ??? This might be an improvement,
        !          6276:      but needs to be thought about some more.  */
        !          6277: #if 0
        !          6278:   keep_next_level_flag = 1;
        !          6279: #endif
        !          6280: 
        !          6281:   /* Write a record describing this function definition to the prototypes
        !          6282:      file (if requested).  */
        !          6283: 
        !          6284:   gen_aux_info_record (fndecl, 1, 0, prototype);
        !          6285: 
        !          6286:   /* Initialize the RTL code for the function.  */
        !          6287: 
        !          6288:   init_function_start (fndecl, input_filename, lineno);
        !          6289: 
        !          6290:   /* If this is a varargs function, inform function.c.  */
        !          6291: 
        !          6292:   if (c_function_varargs)
        !          6293:     mark_varargs ();
        !          6294: 
        !          6295:   /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function.  */
        !          6296: 
        !          6297:   declare_function_name ();
        !          6298: 
        !          6299:   /* Set up parameters and prepare for return, for the function.  */
        !          6300: 
        !          6301:   expand_function_start (fndecl, 0);
        !          6302: 
        !          6303:   /* If this function is `main', emit a call to `__main'
        !          6304:      to run global initializers, etc.  */
        !          6305:   if (DECL_NAME (fndecl)
        !          6306:       && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
        !          6307:       && DECL_CONTEXT (fndecl) == NULL_TREE)
        !          6308:     expand_main_function ();
        !          6309: }
        !          6310: 
        !          6311: /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
        !          6312:    each with a parm name as the TREE_VALUE.  A null pointer as TREE_VALUE
        !          6313:    stands for an ellipsis in the identifier list.
        !          6314: 
        !          6315:    PARMLIST is the data returned by get_parm_info for the
        !          6316:    parmlist that follows the semicolon.
        !          6317: 
        !          6318:    We return a value of the same sort that get_parm_info returns,
        !          6319:    except that it describes the combination of identifiers and parmlist.  */
        !          6320: 
        !          6321: tree
        !          6322: combine_parm_decls (specparms, parmlist, void_at_end)
        !          6323:      tree specparms, parmlist;
        !          6324:      int void_at_end;
        !          6325: {
        !          6326:   register tree fndecl = current_function_decl;
        !          6327:   register tree parm;
        !          6328: 
        !          6329:   tree parmdecls = TREE_PURPOSE (parmlist);
        !          6330: 
        !          6331:   /* This is a chain of any other decls that came in among the parm
        !          6332:      declarations.  They were separated already by get_parm_info,
        !          6333:      so we just need to keep them separate.  */
        !          6334:   tree nonparms = TREE_VALUE (parmlist);
        !          6335: 
        !          6336:   tree types = 0;
        !          6337: 
        !          6338:   for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
        !          6339:     DECL_RESULT (parm) = 0;
        !          6340: 
        !          6341:   for (parm = specparms; parm; parm = TREE_CHAIN (parm))
        !          6342:     {
        !          6343:       register tree tail, found = NULL;
        !          6344: 
        !          6345:       /* See if any of the parmdecls specifies this parm by name.  */
        !          6346:       for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
        !          6347:        if (DECL_NAME (tail) == TREE_VALUE (parm))
        !          6348:          {
        !          6349:            found = tail;
        !          6350:            break;
        !          6351:          }
        !          6352: 
        !          6353:       /* If declaration already marked, we have a duplicate name.
        !          6354:         Complain, and don't use this decl twice.   */
        !          6355:       if (found && DECL_RESULT (found) != 0)
        !          6356:        {
        !          6357:          error_with_decl (found, "multiple parameters named `%s'");
        !          6358:          found = 0;
        !          6359:        }
        !          6360: 
        !          6361:       /* If the declaration says "void", complain and ignore it.  */
        !          6362:       if (found && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == void_type_node)
        !          6363:        {
        !          6364:          error_with_decl (found, "parameter `%s' declared void");
        !          6365:          TREE_TYPE (found) = integer_type_node;
        !          6366:          DECL_ARG_TYPE (found) = integer_type_node;
        !          6367:          layout_decl (found, 0);
        !          6368:        }
        !          6369: 
        !          6370:       /* Traditionally, a parm declared float is actually a double.  */
        !          6371:       if (found && flag_traditional
        !          6372:          && TYPE_MAIN_VARIANT (TREE_TYPE (found)) == float_type_node)
        !          6373:        {
        !          6374:          TREE_TYPE (found) = double_type_node;
        !          6375:          DECL_ARG_TYPE (found) = double_type_node;
        !          6376:          layout_decl (found, 0);
        !          6377:        }
        !          6378: 
        !          6379:       /* If no declaration found, default to int.  */
        !          6380:       if (!found)
        !          6381:        {
        !          6382:          found = build_decl (PARM_DECL, TREE_VALUE (parm),
        !          6383:                              integer_type_node);
        !          6384:          DECL_ARG_TYPE (found) = TREE_TYPE (found);
        !          6385:          DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
        !          6386:          DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
        !          6387:          error_with_decl (found, "type of parameter `%s' is not declared");
        !          6388:          pushdecl (found);
        !          6389:        }
        !          6390: 
        !          6391:       TREE_PURPOSE (parm) = found;
        !          6392: 
        !          6393:       /* Mark this decl as "already found" -- see test, above.
        !          6394:         It is safe to use DECL_RESULT for this
        !          6395:         since it is not used in PARM_DECLs or CONST_DECLs.  */
        !          6396:       DECL_RESULT (found) = error_mark_node;
        !          6397:     }
        !          6398: 
        !          6399:   /* Complain about any actual PARM_DECLs not matched with any names.  */
        !          6400: 
        !          6401:   for (parm = parmdecls; parm; )
        !          6402:     {
        !          6403:       tree next = TREE_CHAIN (parm);
        !          6404:       TREE_CHAIN (parm) = 0;
        !          6405: 
        !          6406:       /* Complain about args with incomplete types.  */
        !          6407:       if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
        !          6408:        {
        !          6409:          error_with_decl (parm, "parameter `%s' has incomplete type");
        !          6410:          TREE_TYPE (parm) = error_mark_node;
        !          6411:        }
        !          6412: 
        !          6413:       if (DECL_RESULT (parm) == 0)
        !          6414:        {
        !          6415:          error_with_decl (parm,
        !          6416:                           "declaration for parameter `%s' but no such parameter");
        !          6417:          /* Pretend the parameter was not missing.
        !          6418:             This gets us to a standard state and minimizes
        !          6419:             further error messages.  */
        !          6420:          specparms
        !          6421:            = chainon (specparms,
        !          6422:                       tree_cons (parm, NULL_TREE, NULL_TREE));
        !          6423:        }
        !          6424: 
        !          6425:       parm = next;
        !          6426:     }
        !          6427: 
        !          6428:   /* Chain the declarations together in the order of the list of names.
        !          6429:      At the same time, build up a list of their types, in reverse order.  */
        !          6430: 
        !          6431:   parm = specparms;
        !          6432:   parmdecls = 0;
        !          6433:   {
        !          6434:     register tree last;
        !          6435:     for (last = 0; parm; parm = TREE_CHAIN (parm))
        !          6436:       if (TREE_PURPOSE (parm))
        !          6437:        {
        !          6438:          if (last == 0)
        !          6439:            parmdecls = TREE_PURPOSE (parm);
        !          6440:          else
        !          6441:            TREE_CHAIN (last) = TREE_PURPOSE (parm);
        !          6442:          last = TREE_PURPOSE (parm);
        !          6443:          TREE_CHAIN (last) = 0;
        !          6444: 
        !          6445:          types = saveable_tree_cons (NULL_TREE, TREE_TYPE (parm), types);
        !          6446:        }
        !          6447:   }
        !          6448:   
        !          6449:   if (void_at_end)
        !          6450:     return saveable_tree_cons (parmdecls, nonparms,
        !          6451:                               nreverse (saveable_tree_cons (NULL_TREE, void_type_node, types)));
        !          6452: 
        !          6453:   return saveable_tree_cons (parmdecls, nonparms, nreverse (types));
        !          6454: }
        !          6455: 
        !          6456: /* Finish up a function declaration and compile that function
        !          6457:    all the way to assembler language output.  The free the storage
        !          6458:    for the function definition.
        !          6459: 
        !          6460:    This is called after parsing the body of the function definition.
        !          6461: 
        !          6462:    NESTED is nonzero if the function being finished is nested in another.  */
        !          6463: 
        !          6464: void
        !          6465: finish_function (nested)
        !          6466:      int nested;
        !          6467: {
        !          6468:   register tree fndecl = current_function_decl;
        !          6469: 
        !          6470: /*  TREE_READONLY (fndecl) = 1;
        !          6471:     This caused &foo to be of type ptr-to-const-function
        !          6472:     which then got a warning when stored in a ptr-to-function variable.  */
        !          6473: 
        !          6474:   poplevel (1, 0, 1);
        !          6475:   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
        !          6476: 
        !          6477:   /* Must mark the RESULT_DECL as being in this function.  */
        !          6478: 
        !          6479:   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
        !          6480: 
        !          6481:   /* Obey `register' declarations if `setjmp' is called in this fn.  */
        !          6482: #ifdef NEXT_SEMANTICS
        !          6483:   /* Be even more conservative on NeXT so that exception handling
        !          6484:      will work reliably. */
        !          6485:   if (current_function_calls_setjmp)
        !          6486: #else
        !          6487:   if (flag_traditional && current_function_calls_setjmp)
        !          6488: #endif
        !          6489:     {
        !          6490:       setjmp_protect (DECL_INITIAL (fndecl));
        !          6491:       setjmp_protect_args ();
        !          6492:     }
        !          6493: 
        !          6494: #ifdef DEFAULT_MAIN_RETURN
        !          6495:   if (! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main"))
        !          6496:     {
        !          6497:       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl)))
        !          6498:          != integer_type_node)
        !          6499:        warning_with_decl (fndecl, "return type of `%s' is not `int'");
        !          6500:       else
        !          6501:        {
        !          6502:          /* Make it so that `main' always returns success by default.  */
        !          6503:          DEFAULT_MAIN_RETURN;
        !          6504:        }
        !          6505:     }
        !          6506: #endif
        !          6507: 
        !          6508:   /* Generate rtl for function exit.  */
        !          6509:   expand_function_end (input_filename, lineno, 0);
        !          6510: 
        !          6511:   /* So we can tell if jump_optimize sets it to 1.  */
        !          6512:   can_reach_end = 0;
        !          6513: 
        !          6514:   /* Run the optimizers and output the assembler code for this function.  */
        !          6515:   rest_of_compilation (fndecl);
        !          6516: 
        !          6517:   current_function_returns_null |= can_reach_end;
        !          6518: 
        !          6519:   if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
        !          6520:     warning ("`volatile' function does return");
        !          6521:   else if (warn_return_type && can_reach_end
        !          6522:           && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (fndecl))) != void_type_node)
        !          6523:     /* If this function returns non-void and control can drop through,
        !          6524:        complain.  */
        !          6525:     warning ("control reaches end of non-void function");
        !          6526:   /* With just -W, complain only if function returns both with
        !          6527:      and without a value.  */
        !          6528:   else if (extra_warnings
        !          6529:           && current_function_returns_value && current_function_returns_null)
        !          6530:     warning ("this function may return with or without a value");
        !          6531: 
        !          6532:   /* Free all the tree nodes making up this function.  */
        !          6533:   /* Switch back to allocating nodes permanently
        !          6534:      until we start another function.  */
        !          6535:   if (! nested)
        !          6536:     permanent_allocation ();
        !          6537: 
        !          6538:   if (DECL_SAVED_INSNS (fndecl) == 0 && ! nested)
        !          6539:     {
        !          6540:       /* Stop pointing to the local nodes about to be freed.  */
        !          6541:       /* But DECL_INITIAL must remain nonzero so we know this
        !          6542:         was an actual function definition.  */
        !          6543:       /* For a nested function, this is done in pop_c_function_context.  */
        !          6544:       /* If rest_of_compilation set this to 0, leave it 0.  */
        !          6545:       if (DECL_INITIAL (fndecl) != 0)
        !          6546:        DECL_INITIAL (fndecl) = error_mark_node;
        !          6547:       DECL_ARGUMENTS (fndecl) = 0;
        !          6548:     }
        !          6549: 
        !          6550:   if (! nested)
        !          6551:     {
        !          6552:       /* Let the error reporting routines know that we're outside a
        !          6553:         function.  For a nested function, this value is used in
        !          6554:         pop_c_function_context and then reset via pop_function_context.  */
        !          6555:       current_function_decl = NULL;
        !          6556:     }
        !          6557: }
        !          6558: 
        !          6559: /* Save and restore the variables in this file and elsewhere
        !          6560:    that keep track of the progress of compilation of the current function.
        !          6561:    Used for nested functions.  */
        !          6562: 
        !          6563: struct c_function
        !          6564: {
        !          6565:   struct c_function *next;
        !          6566:   tree named_labels;
        !          6567:   tree shadowed_labels;
        !          6568:   int returns_value;
        !          6569:   int returns_null;
        !          6570:   int warn_about_return_type;
        !          6571:   int extern_inline;
        !          6572:   struct binding_level *binding_level;
        !          6573: };
        !          6574: 
        !          6575: struct c_function *c_function_chain;
        !          6576: 
        !          6577: /* Save and reinitialize the variables
        !          6578:    used during compilation of a C function.  */
        !          6579: 
        !          6580: void
        !          6581: push_c_function_context ()
        !          6582: {
        !          6583:   struct c_function *p
        !          6584:     = (struct c_function *) xmalloc (sizeof (struct c_function));
        !          6585: 
        !          6586:   if (pedantic)
        !          6587:     pedwarn ("ANSI C forbids nested functions");
        !          6588: 
        !          6589:   push_function_context ();
        !          6590: 
        !          6591:   p->next = c_function_chain;
        !          6592:   c_function_chain = p;
        !          6593: 
        !          6594:   p->named_labels = named_labels;
        !          6595:   p->shadowed_labels = shadowed_labels;
        !          6596:   p->returns_value = current_function_returns_value;
        !          6597:   p->returns_null = current_function_returns_null;
        !          6598:   p->warn_about_return_type = warn_about_return_type;
        !          6599:   p->extern_inline = current_extern_inline;
        !          6600:   p->binding_level = current_binding_level;
        !          6601: }
        !          6602: 
        !          6603: /* Restore the variables used during compilation of a C function.  */
        !          6604: 
        !          6605: void
        !          6606: pop_c_function_context ()
        !          6607: {
        !          6608:   struct c_function *p = c_function_chain;
        !          6609:   tree link;
        !          6610: 
        !          6611:   /* Bring back all the labels that were shadowed.  */
        !          6612:   for (link = shadowed_labels; link; link = TREE_CHAIN (link))
        !          6613:     if (DECL_NAME (TREE_VALUE (link)) != 0)
        !          6614:       IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)))
        !          6615:        = TREE_VALUE (link);
        !          6616: 
        !          6617:   if (DECL_SAVED_INSNS (current_function_decl) == 0)
        !          6618:     {
        !          6619:       /* Stop pointing to the local nodes about to be freed.  */
        !          6620:       /* But DECL_INITIAL must remain nonzero so we know this
        !          6621:         was an actual function definition.  */
        !          6622:       DECL_INITIAL (current_function_decl) = error_mark_node;
        !          6623:       DECL_ARGUMENTS (current_function_decl) = 0;
        !          6624:     }
        !          6625: 
        !          6626:   pop_function_context ();
        !          6627: 
        !          6628:   c_function_chain = p->next;
        !          6629: 
        !          6630:   named_labels = p->named_labels;
        !          6631:   shadowed_labels = p->shadowed_labels;
        !          6632:   current_function_returns_value = p->returns_value;
        !          6633:   current_function_returns_null = p->returns_null;
        !          6634:   warn_about_return_type = p->warn_about_return_type;
        !          6635:   current_extern_inline = p->extern_inline;
        !          6636:   current_binding_level = p->binding_level;
        !          6637: 
        !          6638:   free (p);
        !          6639: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.