gcc/c-decl.c

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