contrib/gcc/cp/semantics.c

   1 /* Perform the semantic phase of parsing, i.e., the process of
   2    building tree structure, checking semantic consistency, and
   3    building RTL.  These routines are used both during actual parsing
   4    and during the instantiation of template functions.
   5
   6    Copyright (C) 1998, 1999 Free Software Foundation, Inc.
   7    Written by Mark Mitchell (mmitchell@usa.net) based on code found
   8    formerly in parse.y and pt.c.
   9
  10    This file is part of GNU CC.
  11
  12    GNU CC is free software; you can redistribute it and/or modify it
  13    under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 2, or (at your option)
  15    any later version.
  16
  17    GNU CC is distributed in the hope that it will be useful, but
  18    WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with GNU CC; see the file COPYING.  If not, write to the Free
  24    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25    02111-1307, USA.  */
  26
  27 #include "config.h"
  28 #include "system.h"
  29 #include "tree.h"
  30 #include "cp-tree.h"
  31 #include "except.h"
  32 #include "lex.h"
  33 #include "toplev.h"
  34
  35 /* There routines provide a modular interface to perform many parsing
  36    operations.  They may therefore be used during actual parsing, or
  37    during template instantiation, which may be regarded as a
  38    degenerate form of parsing.  Since the current g++ parser is
  39    lacking in several respects, and will be reimplemented, we are
  40    attempting to move most code that is not directly related to
  41    parsing into this file; that will make implementing the new parser
  42    much easier since it will be able to make use of these routines.  */
  43
  44 /* When parsing a template, LAST_TREE contains the last statement
  45    parsed.  These are chained together through the TREE_CHAIN field,
  46    but often need to be re-organized since the parse is performed
  47    bottom-up.  This macro makes LAST_TREE the indicated SUBSTMT of
  48    STMT.  */
  49
  50 #define RECHAIN_STMTS(stmt, substmt, last)      \
  51   do {                                          \
  52     substmt = last;                             \
  53     TREE_CHAIN (stmt) = NULL_TREE;              \
  54     last_tree = stmt;                           \
  55   } while (0)
  56
  57 #define RECHAIN_STMTS_FROM_LAST(stmt, substmt)  \
  58   RECHAIN_STMTS (stmt, substmt, last_tree)
  59
  60 #define RECHAIN_STMTS_FROM_CHAIN(stmt, substmt) \
  61   RECHAIN_STMTS (stmt, substmt, TREE_CHAIN (stmt))
  62
  63 /* Finish an expression-statement, whose EXPRESSION is as indicated.  */
  64
  65 void
  66 finish_expr_stmt (expr)
  67      tree expr;
  68 {
  69   if (expr != NULL_TREE)
  70     {
  71       if (!processing_template_decl)
  72         {
  73           emit_line_note (input_filename, lineno);
  74           /* Do default conversion if safe and possibly important,
  75              in case within ({...}).  */
  76           if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
  77                && lvalue_p (expr))
  78               || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
  79             expr = default_conversion (expr);
  80         }
  81
  82       cplus_expand_expr_stmt (expr);
  83       clear_momentary ();
  84     }
  85
  86   finish_stmt ();
  87 }
  88
  89 /* Begin an if-statement.  Returns a newly created IF_STMT if
  90    appropriate.  */
  91
  92 tree
  93 begin_if_stmt ()
  94 {
  95   tree r;
  96
  97   if (processing_template_decl)
  98     {
  99       r = build_min_nt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 100       add_tree (r);
 101     }
 102   else
 103     r = NULL_TREE;
 104
 105   do_pushlevel ();
 106
 107   return r;
 108 }
 109
 110 /* Process the COND of an if-statement, which may be given by
 111    IF_STMT.  */
 112
 113 void
 114 finish_if_stmt_cond (cond, if_stmt)
 115      tree cond;
 116      tree if_stmt;
 117 {
 118   if (processing_template_decl)
 119     {
 120       if (last_tree != if_stmt)
 121         RECHAIN_STMTS_FROM_LAST (if_stmt, IF_COND (if_stmt));
 122       else
 123         IF_COND (if_stmt) = copy_to_permanent (cond);
 124     }
 125   else
 126     {
 127       emit_line_note (input_filename, lineno);
 128       expand_start_cond (condition_conversion (cond), 0);
 129     }
 130 }
 131
 132 /* Finish the then-clause of an if-statement, which may be given by
 133    IF_STMT.  */
 134
 135 tree
 136 finish_then_clause (if_stmt)
 137      tree if_stmt;
 138 {
 139   if (processing_template_decl)
 140     {
 141       RECHAIN_STMTS_FROM_CHAIN (if_stmt,
 142                                 THEN_CLAUSE (if_stmt));
 143       last_tree = if_stmt;
 144       return if_stmt;
 145     }
 146   else
 147     return NULL_TREE;
 148 }
 149
 150 /* Begin the else-clause of an if-statement.  */
 151
 152 void
 153 begin_else_clause ()
 154 {
 155   if (!processing_template_decl)
 156     expand_start_else ();
 157 }
 158
 159 /* Finish the else-clause of an if-statement, which may be given by
 160    IF_STMT.  */
 161
 162 void
 163 finish_else_clause (if_stmt)
 164      tree if_stmt;
 165 {
 166   if (processing_template_decl)
 167     RECHAIN_STMTS_FROM_CHAIN (if_stmt, ELSE_CLAUSE (if_stmt));
 168 }
 169
 170 /* Finsh an if-statement.  */
 171
 172 void
 173 finish_if_stmt ()
 174 {
 175   if (!processing_template_decl)
 176     expand_end_cond ();
 177
 178   do_poplevel ();
 179   finish_stmt ();
 180 }
 181
 182 /* Begin a while-statement.  Returns a newly created WHILE_STMT if
 183    appropriate.  */
 184
 185 tree
 186 begin_while_stmt ()
 187 {
 188   tree r;
 189
 190   if (processing_template_decl)
 191     {
 192       r = build_min_nt (WHILE_STMT, NULL_TREE, NULL_TREE);
 193       add_tree (r);
 194     }
 195   else
 196     {
 197       emit_nop ();
 198       emit_line_note (input_filename, lineno);
 199       expand_start_loop (1);
 200       r = NULL_TREE;
 201     }
 202
 203   do_pushlevel ();
 204
 205   return r;
 206 }
 207
 208 /* Process the COND of an if-statement, which may be given by
 209    WHILE_STMT.  */
 210
 211 void
 212 finish_while_stmt_cond (cond, while_stmt)
 213      tree cond;
 214      tree while_stmt;
 215 {
 216   if (processing_template_decl)
 217     {
 218       if (last_tree != while_stmt)
 219         RECHAIN_STMTS_FROM_LAST (while_stmt,
 220                                       WHILE_COND (while_stmt));
 221       else
 222         TREE_OPERAND (while_stmt, 0) = copy_to_permanent (cond);
 223     }
 224   else
 225     {
 226       emit_line_note (input_filename, lineno);
 227       expand_exit_loop_if_false (0, condition_conversion (cond));
 228     }
 229
 230   /* If COND wasn't a declaration, clear out the
 231      block we made for it and start a new one here so the
 232      optimization in expand_end_loop will work.  */
 233   if (getdecls () == NULL_TREE)
 234     {
 235       do_poplevel ();
 236       do_pushlevel ();
 237     }
 238 }
 239
 240 /* Finish a while-statement, which may be given by WHILE_STMT.  */
 241
 242 void
 243 finish_while_stmt (while_stmt)
 244      tree while_stmt;
 245 {
 246   do_poplevel ();
 247
 248   if (processing_template_decl)
 249     RECHAIN_STMTS_FROM_CHAIN (while_stmt, WHILE_BODY (while_stmt));
 250   else
 251     expand_end_loop ();
 252   finish_stmt ();
 253 }
 254
 255 /* Begin a do-statement.  Returns a newly created DO_STMT if
 256    appropriate.  */
 257
 258 tree
 259 begin_do_stmt ()
 260 {
 261   if (processing_template_decl)
 262     {
 263       tree r = build_min_nt (DO_STMT, NULL_TREE, NULL_TREE);
 264       add_tree (r);
 265       return r;
 266     }
 267   else
 268     {
 269       emit_nop ();
 270       emit_line_note (input_filename, lineno);
 271       expand_start_loop_continue_elsewhere (1);
 272       return NULL_TREE;
 273     }
 274 }
 275
 276 /* Finish the body of a do-statement, which may be given by DO_STMT.  */
 277
 278 void
 279 finish_do_body (do_stmt)
 280      tree do_stmt;
 281 {
 282   if (processing_template_decl)
 283     RECHAIN_STMTS_FROM_CHAIN (do_stmt, DO_BODY (do_stmt));
 284   else
 285     expand_loop_continue_here ();
 286 }
 287
 288 /* Finish a do-statement, which may be given by DO_STMT, and whose
 289    COND is as indicated.  */
 290
 291 void
 292 finish_do_stmt (cond, do_stmt)
 293      tree cond;
 294      tree do_stmt;
 295 {
 296   if (processing_template_decl)
 297     DO_COND (do_stmt) = copy_to_permanent (cond);
 298   else
 299     {
 300       emit_line_note (input_filename, lineno);
 301       expand_exit_loop_if_false (0, condition_conversion (cond));
 302       expand_end_loop ();
 303     }
 304
 305   clear_momentary ();
 306   finish_stmt ();
 307 }
 308
 309 /* Finish a return-statement.  The EXPRESSION returned, if any, is as
 310    indicated.  */
 311
 312 void
 313 finish_return_stmt (expr)
 314      tree expr;
 315 {
 316   emit_line_note (input_filename, lineno);
 317   c_expand_return (expr);
 318   finish_stmt ();
 319 }
 320
 321 /* Begin a for-statement.  Returns a new FOR_STMT if appropriate.  */
 322
 323 tree
 324 begin_for_stmt ()
 325 {
 326   tree r;
 327
 328   if (processing_template_decl)
 329     {
 330       r = build_min_nt (FOR_STMT, NULL_TREE, NULL_TREE,
 331                         NULL_TREE, NULL_TREE);
 332       add_tree (r);
 333     }
 334   else
 335     r = NULL_TREE;
 336
 337   if (flag_new_for_scope > 0)
 338     {
 339       do_pushlevel ();
 340       note_level_for_for ();
 341     }
 342
 343   return r;
 344 }
 345
 346 /* Finish the for-init-statement of a for-statement, which may be
 347    given by FOR_STMT.  */
 348
 349 void
 350 finish_for_init_stmt (for_stmt)
 351      tree for_stmt;
 352 {
 353   if (processing_template_decl)
 354     {
 355       if (last_tree != for_stmt)
 356         RECHAIN_STMTS_FROM_CHAIN (for_stmt, FOR_INIT_STMT (for_stmt));
 357     }
 358   else
 359     {
 360       emit_nop ();
 361       emit_line_note (input_filename, lineno);
 362       expand_start_loop_continue_elsewhere (1);
 363     }
 364
 365   do_pushlevel ();
 366 }
 367
 368 /* Finish the COND of a for-statement, which may be given by
 369    FOR_STMT.  */
 370
 371 void
 372 finish_for_cond (cond, for_stmt)
 373      tree cond;
 374      tree for_stmt;
 375 {
 376   if (processing_template_decl)
 377     {
 378       if (last_tree != for_stmt)
 379         RECHAIN_STMTS_FROM_LAST (for_stmt, FOR_COND (for_stmt));
 380       else
 381         FOR_COND (for_stmt) = copy_to_permanent (cond);
 382     }
 383   else
 384     {
 385       emit_line_note (input_filename, lineno);
 386       if (cond)
 387         expand_exit_loop_if_false (0, condition_conversion (cond));
 388     }
 389
 390   /* If the cond wasn't a declaration, clear out the
 391      block we made for it and start a new one here so the
 392      optimization in expand_end_loop will work.  */
 393   if (getdecls () == NULL_TREE)
 394     {
 395       do_poplevel ();
 396       do_pushlevel ();
 397     }
 398 }
 399
 400 /* Finish the increment-EXPRESSION in a for-statement, which may be
 401    given by FOR_STMT.  */
 402
 403 void
 404 finish_for_expr (expr, for_stmt)
 405      tree expr;
 406      tree for_stmt;
 407 {
 408   if (processing_template_decl)
 409     FOR_EXPR (for_stmt) = expr;
 410
 411   /* Don't let the tree nodes for EXPR be discarded
 412      by clear_momentary during the parsing of the next stmt.  */
 413   push_momentary ();
 414 }
 415
 416 /* Finish the body of a for-statement, which may be given by
 417    FOR_STMT.  The increment-EXPR for the loop must be
 418    provided.  */
 419
 420 void
 421 finish_for_stmt (expr, for_stmt)
 422      tree expr;
 423      tree for_stmt;
 424 {
 425   /* Pop the scope for the body of the loop.  */
 426   do_poplevel ();
 427
 428   if (processing_template_decl)
 429     RECHAIN_STMTS_FROM_CHAIN (for_stmt, FOR_BODY (for_stmt));
 430   else
 431     {
 432       emit_line_note (input_filename, lineno);
 433       expand_loop_continue_here ();
 434       if (expr)
 435         cplus_expand_expr_stmt (expr);
 436       expand_end_loop ();
 437     }
 438
 439   pop_momentary ();
 440
 441   if (flag_new_for_scope > 0)
 442     do_poplevel ();
 443
 444   finish_stmt ();
 445 }
 446
 447 /* Finish a break-statement.  */
 448
 449 void
 450 finish_break_stmt ()
 451 {
 452   emit_line_note (input_filename, lineno);
 453   if (processing_template_decl)
 454     add_tree (build_min_nt (BREAK_STMT));
 455   else if ( ! expand_exit_something ())
 456     cp_error ("break statement not within loop or switch");
 457 }
 458
 459 /* Finish a continue-statement.  */
 460
 461 void
 462 finish_continue_stmt ()
 463 {
 464   emit_line_note (input_filename, lineno);
 465   if (processing_template_decl)
 466     add_tree (build_min_nt (CONTINUE_STMT));
 467   else if (! expand_continue_loop (0))
 468     cp_error ("continue statement not within a loop");
 469 }
 470
 471 /* Begin a switch-statement.  */
 472
 473 void
 474 begin_switch_stmt ()
 475 {
 476   do_pushlevel ();
 477 }
 478
 479 /* Finish the cond of a switch-statement.  Returns a new
 480    SWITCH_STMT if appropriate.  */
 481
 482 tree
 483 finish_switch_cond (cond)
 484      tree cond;
 485 {
 486   tree r;
 487
 488   if (processing_template_decl)
 489     {
 490       r = build_min_nt (SWITCH_STMT, cond, NULL_TREE);
 491       add_tree (r);
 492     }
 493   else if (cond != error_mark_node)
 494     {
 495       emit_line_note (input_filename, lineno);
 496       c_expand_start_case (cond);
 497       r = NULL_TREE;
 498     }
 499   else
 500     {
 501       /* The code is in error, but we don't want expand_end_case to
 502          crash. */
 503       c_expand_start_case (boolean_false_node);
 504       r = NULL_TREE;
 505     }
 506
 507   push_switch ();
 508
 509   /* Don't let the tree nodes for COND be discarded by
 510      clear_momentary during the parsing of the next stmt.  */
 511   push_momentary ();
 512
 513   return r;
 514 }
 515
 516 /* Finish the body of a switch-statement, which may be given by
 517    SWITCH_STMT.  The COND to switch on is indicated.  */
 518
 519 void
 520 finish_switch_stmt (cond, switch_stmt)
 521      tree cond;
 522      tree switch_stmt;
 523 {
 524   if (processing_template_decl)
 525     RECHAIN_STMTS_FROM_CHAIN (switch_stmt, SWITCH_BODY (switch_stmt));
 526   else
 527     expand_end_case (cond);
 528   pop_momentary ();
 529   pop_switch ();
 530   do_poplevel ();
 531   finish_stmt ();
 532 }
 533
 534 /* Finish a case-label.  */
 535
 536 void
 537 finish_case_label (low_value, high_value)
 538      tree low_value;
 539      tree high_value;
 540 {
 541   do_case (low_value, high_value);
 542 }
 543
 544
 545 /* Finish a goto-statement.  */
 546
 547 void
 548 finish_goto_stmt (destination)
 549      tree destination;
 550 {
 551   if (processing_template_decl)
 552     add_tree (build_min_nt (GOTO_STMT, destination));
 553   else
 554     {
 555       emit_line_note (input_filename, lineno);
 556
 557       if (TREE_CODE (destination) == IDENTIFIER_NODE)
 558         {
 559           tree decl = lookup_label (destination);
 560           TREE_USED (decl) = 1;
 561           expand_goto (decl);
 562         }
 563       else
 564         expand_computed_goto (destination);
 565     }
 566 }
 567
 568 /* Begin a try-block.  Returns a newly-created TRY_BLOCK if
 569    appropriate.  */
 570
 571 tree
 572 begin_try_block ()
 573 {
 574   if (processing_template_decl)
 575     {
 576       tree r = build_min_nt (TRY_BLOCK, NULL_TREE,
 577                              NULL_TREE);
 578       add_tree (r);
 579       return r;
 580     }
 581   else
 582     {
 583       emit_line_note (input_filename, lineno);
 584       expand_start_try_stmts ();
 585       return NULL_TREE;
 586     }
 587 }
 588
 589 /* Finish a try-block, which may be given by TRY_BLOCK.  */
 590
 591 void
 592 finish_try_block (try_block)
 593      tree try_block;
 594 {
 595   if (processing_template_decl)
 596     RECHAIN_STMTS_FROM_LAST (try_block, TRY_STMTS (try_block));
 597   else
 598     {
 599       expand_start_all_catch ();
 600     }
 601 }
 602
 603 /* Finish a handler-sequence for a try-block, which may be given by
 604    TRY_BLOCK.  */
 605
 606 void
 607 finish_handler_sequence (try_block)
 608      tree try_block;
 609 {
 610   if (processing_template_decl)
 611     RECHAIN_STMTS_FROM_CHAIN (try_block, TRY_HANDLERS (try_block));
 612   else
 613     {
 614       expand_end_all_catch ();
 615     }
 616 }
 617
 618 /* Begin a handler.  Returns a HANDLER if appropriate.  */
 619
 620 tree
 621 begin_handler ()
 622 {
 623   tree r;
 624
 625   if (processing_template_decl)
 626     {
 627       r = build_min_nt (HANDLER, NULL_TREE, NULL_TREE);
 628       add_tree (r);
 629     }
 630   else
 631     r = NULL_TREE;
 632
 633   do_pushlevel ();
 634
 635   return r;
 636 }
 637
 638 /* Finish the handler-parameters for a handler, which may be given by
 639    HANDLER.  */
 640
 641 void
 642 finish_handler_parms (handler)
 643      tree handler;
 644 {
 645   if (processing_template_decl)
 646     RECHAIN_STMTS_FROM_CHAIN (handler, HANDLER_PARMS (handler));
 647 }
 648
 649 /* Finish a handler, which may be given by HANDLER.  */
 650
 651 void
 652 finish_handler (handler)
 653      tree handler;
 654 {
 655   if (processing_template_decl)
 656     RECHAIN_STMTS_FROM_CHAIN (handler, HANDLER_BODY (handler));
 657   else
 658     expand_end_catch_block ();
 659
 660   do_poplevel ();
 661 }
 662
 663 /* Begin a compound-statement.  If HAS_NO_SCOPE is non-zero, the
 664    compound-statement does not define a scope.  Returns a new
 665    COMPOUND_STMT if appropriate.  */
 666
 667 tree
 668 begin_compound_stmt (has_no_scope)
 669      int has_no_scope;
 670 {
 671   tree r;
 672
 673   if (processing_template_decl)
 674     {
 675       r = build_min_nt (COMPOUND_STMT, NULL_TREE);
 676       add_tree (r);
 677       if (has_no_scope)
 678         COMPOUND_STMT_NO_SCOPE (r) = 1;
 679     }
 680   else
 681     r = NULL_TREE;
 682
 683   if (!has_no_scope)
 684     do_pushlevel ();
 685
 686   return r;
 687 }
 688
 689
 690 /* Finish a compound-statement, which may be given by COMPOUND_STMT.
 691    If HAS_NO_SCOPE is non-zero, the compound statement does not define
 692    a scope.  */
 693
 694 tree
 695 finish_compound_stmt (has_no_scope, compound_stmt)
 696      int has_no_scope;
 697      tree compound_stmt;
 698 {
 699   tree r;
 700
 701   if (!has_no_scope)
 702     r = do_poplevel ();
 703   else
 704     r = NULL_TREE;
 705
 706   if (processing_template_decl)
 707     RECHAIN_STMTS_FROM_CHAIN (compound_stmt,
 708                               COMPOUND_BODY (compound_stmt));
 709
 710   finish_stmt ();
 711
 712   return r;
 713 }
 714
 715 /* Finish an asm-statement, whose components are a CV_QUALIFIER, a
 716    STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
 717    CLOBBERS.  */
 718
 719 void
 720 finish_asm_stmt (cv_qualifier, string, output_operands,
 721                       input_operands, clobbers)
 722      tree cv_qualifier;
 723      tree string;
 724      tree output_operands;
 725      tree input_operands;
 726      tree clobbers;
 727 {
 728   if (TREE_CHAIN (string))
 729     string = combine_strings (string);
 730
 731   if (processing_template_decl)
 732     {
 733       tree r = build_min_nt (ASM_STMT, cv_qualifier, string,
 734                              output_operands, input_operands,
 735                              clobbers);
 736       add_tree (r);
 737     }
 738   else
 739     {
 740       emit_line_note (input_filename, lineno);
 741       if (output_operands != NULL_TREE || input_operands != NULL_TREE
 742             || clobbers != NULL_TREE)
 743         {
 744           tree t;
 745
 746           if (cv_qualifier != NULL_TREE
 747               && cv_qualifier != ridpointers[(int) RID_VOLATILE])
 748             cp_warning ("%s qualifier ignored on asm",
 749                         IDENTIFIER_POINTER (cv_qualifier));
 750
 751           for (t = input_operands; t; t = TREE_CHAIN (t))
 752             TREE_VALUE (t) = decay_conversion (TREE_VALUE (t));
 753
 754           c_expand_asm_operands (string, output_operands,
 755                                  input_operands,
 756                                  clobbers,
 757                                  cv_qualifier
 758                                  == ridpointers[(int) RID_VOLATILE],
 759                                  input_filename, lineno);
 760         }
 761       else
 762         {
 763           /* Don't warn about redundant specification of 'volatile' here.  */
 764           if (cv_qualifier != NULL_TREE
 765               && cv_qualifier != ridpointers[(int) RID_VOLATILE])
 766             cp_warning ("%s qualifier ignored on asm",
 767                         IDENTIFIER_POINTER (cv_qualifier));
 768           expand_asm (string);
 769         }
 770
 771       finish_stmt ();
 772     }
 773 }
 774
 775 /* Finish a parenthesized expression EXPR.  */
 776
 777 tree
 778 finish_parenthesized_expr (expr)
 779      tree expr;
 780 {
 781   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
 782     /* This inhibits warnings in truthvalue_conversion.  */
 783     C_SET_EXP_ORIGINAL_CODE (expr, ERROR_MARK);
 784
 785   return expr;
 786 }
 787
 788 /* Begin a statement-expression.  The value returned must be passed to
 789    finish_stmt_expr.  */
 790
 791 tree
 792 begin_stmt_expr ()
 793 {
 794   keep_next_level ();
 795   /* If we're processing_template_decl, then the upcoming compound
 796      statement will be chained onto the tree structure, starting at
 797      last_tree.  We return last_tree so that we can later unhook the
 798      compound statement.  */
 799   return processing_template_decl ? last_tree : expand_start_stmt_expr();
 800 }
 801
 802 /* Finish a statement-expression.  RTL_EXPR should be the value
 803    returned by the previous begin_stmt_expr; EXPR is the
 804    statement-expression.  Returns an expression representing the
 805    statement-expression.  */
 806
 807 tree
 808 finish_stmt_expr (rtl_expr, expr)
 809      tree rtl_expr;
 810      tree expr;
 811 {
 812   tree result;
 813
 814   if (!processing_template_decl)
 815     {
 816       rtl_expr = expand_end_stmt_expr (rtl_expr);
 817       /* The statements have side effects, so the group does.  */
 818       TREE_SIDE_EFFECTS (rtl_expr) = 1;
 819     }
 820
 821   if (TREE_CODE (expr) == BLOCK)
 822     {
 823       /* Make a BIND_EXPR for the BLOCK already made.  */
 824       if (processing_template_decl)
 825         result = build_min_nt (BIND_EXPR, NULL_TREE, last_tree,
 826                                NULL_TREE);
 827       else
 828         result = build (BIND_EXPR, TREE_TYPE (rtl_expr),
 829                         NULL_TREE, rtl_expr, expr);
 830
 831       /* Remove the block from the tree at this point.
 832          It gets put back at the proper place
 833          when the BIND_EXPR is expanded.  */
 834       delete_block (expr);
 835     }
 836   else
 837     result = expr;
 838
 839   if (processing_template_decl)
 840     {
 841       /* Remove the compound statement from the tree structure; it is
 842          now saved in the BIND_EXPR.  */
 843       last_tree = rtl_expr;
 844       TREE_CHAIN (last_tree) = NULL_TREE;
 845     }
 846
 847   return result;
 848 }
 849
 850 /* Finish a call to FN with ARGS.  Returns a representation of the
 851    call.  */
 852
 853 tree
 854 finish_call_expr (fn, args, koenig)
 855      tree fn;
 856      tree args;
 857      int koenig;
 858 {
 859   tree result;
 860
 861   if (koenig)
 862     {
 863       if (TREE_CODE (fn) == BIT_NOT_EXPR)
 864         fn = build_x_unary_op (BIT_NOT_EXPR, TREE_OPERAND (fn, 0));
 865       else if (TREE_CODE (fn) != TEMPLATE_ID_EXPR)
 866         fn = do_identifier (fn, 2, args);
 867     }
 868   result = build_x_function_call (fn, args, current_class_ref);
 869
 870   if (TREE_CODE (result) == CALL_EXPR
 871       && (! TREE_TYPE (result)
 872           || TREE_CODE (TREE_TYPE (result)) != VOID_TYPE))
 873     result = require_complete_type (result);
 874
 875   return result;
 876 }
 877
 878 /* Finish a call to a postfix increment or decrement or EXPR.  (Which
 879    is indicated by CODE, which should be POSTINCREMENT_EXPR or
 880    POSTDECREMENT_EXPR.)  */
 881
 882 tree
 883 finish_increment_expr (expr, code)
 884      tree expr;
 885      enum tree_code code;
 886 {
 887   /* If we get an OFFSET_REF, turn it into what it really means (e.g.,
 888      a COMPONENT_REF).  This way if we've got, say, a reference to a
 889      static member that's being operated on, we don't end up trying to
 890      find a member operator for the class it's in.  */
 891
 892   if (TREE_CODE (expr) == OFFSET_REF)
 893     expr = resolve_offset_ref (expr);
 894   return build_x_unary_op (code, expr);
 895 }
 896
 897 /* Finish a use of `this'.  Returns an expression for `this'.  */
 898
 899 tree
 900 finish_this_expr ()
 901 {
 902   tree result;
 903
 904   if (current_class_ptr)
 905     {
 906 #ifdef WARNING_ABOUT_CCD
 907       TREE_USED (current_class_ptr) = 1;
 908 #endif
 909       result = current_class_ptr;
 910     }
 911   else if (current_function_decl
 912            && DECL_STATIC_FUNCTION_P (current_function_decl))
 913     {
 914       error ("`this' is unavailable for static member functions");
 915       result = error_mark_node;
 916     }
 917   else
 918     {
 919       if (current_function_decl)
 920         error ("invalid use of `this' in non-member function");
 921       else
 922         error ("invalid use of `this' at top level");
 923       result = error_mark_node;
 924     }
 925
 926   return result;
 927 }
 928
 929 /* Finish a member function call using OBJECT and ARGS as arguments to
 930    FN.  Returns an expression for the call.  */
 931
 932 tree
 933 finish_object_call_expr (fn, object, args)
 934      tree fn;
 935      tree object;
 936      tree args;
 937 {
 938 #if 0
 939   /* This is a future direction of this code, but because
 940      build_x_function_call cannot always undo what is done in
 941      build_component_ref entirely yet, we cannot do this.  */
 942
 943   tree real_fn = build_component_ref (object, fn, NULL_TREE, 1);
 944   return finish_call_expr (real_fn, args);
 945 #else
 946   if (TREE_CODE (fn) == TYPE_DECL)
 947     {
 948       if (processing_template_decl)
 949         /* This can happen on code like:
 950
 951            class X;
 952            template <class T> void f(T t) {
 953              t.X();
 954            }
 955
 956            We just grab the underlying IDENTIFIER.  */
 957         fn = DECL_NAME (fn);
 958       else
 959         {
 960           cp_error ("calling type `%T' like a method", fn);
 961           return error_mark_node;
 962         }
 963     }
 964
 965   return build_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
 966 #endif
 967 }
 968
 969 /* Finish a qualified member function call using OBJECT and ARGS as
 970    arguments to FN.  Returns an expressino for the call.  */
 971
 972 tree
 973 finish_qualified_object_call_expr (fn, object, args)
 974      tree fn;
 975      tree object;
 976      tree args;
 977 {
 978   if (IS_SIGNATURE (TREE_OPERAND (fn, 0)))
 979     {
 980       warning ("signature name in scope resolution ignored");
 981       return finish_object_call_expr (TREE_OPERAND (fn, 1), object, args);
 982     }
 983   else
 984     return build_scoped_method_call (object, TREE_OPERAND (fn, 0),
 985                                      TREE_OPERAND (fn, 1), args);
 986 }
 987
 988 /* Finish a pseudo-destructor call expression of OBJECT, with SCOPE
 989    being the scope, if any, of DESTRUCTOR.  Returns an expression for
 990    the call.  */
 991
 992 tree
 993 finish_pseudo_destructor_call_expr (object, scope, destructor)
 994      tree object;
 995      tree scope;
 996      tree destructor;
 997 {
 998   if (scope && scope != destructor)
 999     cp_error ("destructor specifier `%T::~%T()' must have matching names",
1000               scope, destructor);
1001
1002   if ((scope == NULL_TREE || IDENTIFIER_GLOBAL_VALUE (destructor))
1003       && (TREE_CODE (TREE_TYPE (object)) !=
1004           TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (destructor)))))
1005     cp_error ("`%E' is not of type `%T'", object, destructor);
1006
1007   return cp_convert (void_type_node, object);
1008 }
1009
1010 /* Finish a call to a globally qualified member function FN using
1011    ARGS.  Returns an expression for the call.  */
1012
1013 tree
1014 finish_qualified_call_expr (fn, args)
1015      tree fn;
1016      tree args;
1017 {
1018   if (processing_template_decl)
1019     return build_min_nt (CALL_EXPR, copy_to_permanent (fn), args,
1020                          NULL_TREE);
1021   else
1022     return build_member_call (TREE_OPERAND (fn, 0),
1023                               TREE_OPERAND (fn, 1),
1024                               args);
1025 }
1026
1027 /* Finish an expression taking the address of LABEL.  Returns an
1028    expression for the address.  */
1029
1030 tree
1031 finish_label_address_expr (label)
1032      tree label;
1033 {
1034   tree result;
1035
1036   label = lookup_label (label);
1037   if (label == NULL_TREE)
1038     result = null_pointer_node;
1039   else
1040     {
1041       TREE_USED (label) = 1;
1042       result = build1 (ADDR_EXPR, ptr_type_node, label);
1043       TREE_CONSTANT (result) = 1;
1044     }
1045
1046   return result;
1047 }
1048
1049 /* Finish an expression of the form CODE EXPR.  */
1050
1051 tree
1052 finish_unary_op_expr (code, expr)
1053      enum tree_code code;
1054      tree expr;
1055 {
1056   tree result = build_x_unary_op (code, expr);
1057   if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST)
1058     TREE_NEGATED_INT (result) = 1;
1059   overflow_warning (result);
1060   return result;
1061 }
1062
1063 /* Finish an id-expression.  */
1064
1065 tree
1066 finish_id_expr (expr)
1067      tree expr;
1068 {
1069   if (TREE_CODE (expr) == IDENTIFIER_NODE)
1070     expr = do_identifier (expr, 1, NULL_TREE);
1071
1072   return expr;
1073 }
1074
1075 /* Begin a new-placement.  */
1076
1077 int
1078 begin_new_placement ()
1079 {
1080   /* The arguments to a placement new might be passed to a
1081      deallocation function, in the event that the allocation throws an
1082      exception.  Since we don't expand exception handlers until the
1083      end of a function, we must make sure the arguments stay around
1084      that long.  */
1085   return suspend_momentary ();
1086 }
1087
1088 /* Finish a new-placement.  The ARGS are the placement arguments.  The
1089    COOKIE is the value returned by the previous call to
1090    begin_new_placement.  */
1091
1092 tree
1093 finish_new_placement (args, cookie)
1094      tree args;
1095      int cookie;
1096 {
1097   resume_momentary (cookie);
1098   return args;
1099 }
1100
1101 /* Begin a function defniition declared with DECL_SPECS and
1102    DECLARATOR.  Returns non-zero if the function-declaration is
1103    legal.  */
1104
1105 int
1106 begin_function_definition (decl_specs, declarator)
1107      tree decl_specs;
1108      tree declarator;
1109 {
1110   tree specs;
1111   tree attrs;
1112   split_specs_attrs (decl_specs, &specs, &attrs);
1113   if (!start_function (specs, declarator, attrs, 0))
1114     return 0;
1115
1116   reinit_parse_for_function ();
1117   /* The things we're about to see are not directly qualified by any
1118      template headers we've seen thus far.  */
1119   reset_specialization ();
1120
1121   return 1;
1122 }
1123
1124 /* Begin a constructor declarator of the form `SCOPE::NAME'.  Returns
1125    a SCOPE_REF.  */
1126
1127 tree
1128 begin_constructor_declarator (scope, name)
1129      tree scope;
1130      tree name;
1131 {
1132   tree result = build_parse_node (SCOPE_REF, scope, name);
1133   enter_scope_of (result);
1134   return result;
1135 }
1136
1137 /* Finish an init-declarator.  Returns a DECL.  */
1138
1139 tree
1140 finish_declarator (declarator, declspecs, attributes,
1141                    prefix_attributes, initialized)
1142      tree declarator;
1143      tree declspecs;
1144      tree attributes;
1145      tree prefix_attributes;
1146      int initialized;
1147 {
1148   return start_decl (declarator, declspecs, initialized, attributes,
1149                      prefix_attributes);
1150 }
1151
1152 /* Finish a translation unit.  */
1153
1154 void
1155 finish_translation_unit ()
1156 {
1157   /* In case there were missing closebraces,
1158      get us back to the global binding level.  */
1159   while (! toplevel_bindings_p ())
1160     poplevel (0, 0, 0);
1161   while (current_namespace != global_namespace)
1162     pop_namespace ();
1163   finish_file ();
1164 }
1165
1166 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
1167    Returns the parameter.  */
1168
1169 tree
1170 finish_template_type_parm (aggr, identifier)
1171      tree aggr;
1172      tree identifier;
1173 {
1174   if (aggr == signature_type_node)
1175     sorry ("signature as template type parameter");
1176   else if (aggr != class_type_node)
1177     {
1178       pedwarn ("template type parameters must use the keyword `class' or `typename'");
1179       aggr = class_type_node;
1180     }
1181
1182   return build_tree_list (aggr, identifier);
1183 }
1184
1185 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
1186    Returns the parameter.  */
1187
1188 tree
1189 finish_template_template_parm (aggr, identifier)
1190      tree aggr;
1191      tree identifier;
1192 {
1193   tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
1194   tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
1195   DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
1196   DECL_TEMPLATE_RESULT (tmpl) = decl;
1197   SET_DECL_ARTIFICIAL (decl);
1198   end_template_decl ();
1199
1200   return finish_template_type_parm (aggr, tmpl);
1201 }
1202
1203 /* Finish a parameter list, indicated by PARMS.  If ELLIPSIS is
1204    non-zero, the parameter list was terminated by a `...'.  */
1205
1206 tree
1207 finish_parmlist (parms, ellipsis)
1208      tree parms;
1209      int ellipsis;
1210 {
1211   if (!ellipsis)
1212     chainon (parms, void_list_node);
1213   /* We mark the PARMS as a parmlist so that declarator processing can
1214      disambiguate certain constructs.  */
1215   if (parms != NULL_TREE)
1216     TREE_PARMLIST (parms) = 1;
1217
1218   return parms;
1219 }
1220
1221 /* Begin a class definition, as indicated by T.  */
1222
1223 tree
1224 begin_class_definition (t)
1225      tree t;
1226 {
1227   push_obstacks_nochange ();
1228   end_temporary_allocation ();
1229
1230   if (t == error_mark_node
1231       || ! IS_AGGR_TYPE (t))
1232     {
1233       t = make_lang_type (RECORD_TYPE);
1234       pushtag (make_anon_name (), t, 0);
1235     }
1236
1237   /* In a definition of a member class template, we will get here with an
1238      implicit typename, a TYPENAME_TYPE with a type.  */
1239   if (TREE_CODE (t) == TYPENAME_TYPE)
1240     t = TREE_TYPE (t);
1241
1242   /* If we generated a partial instantiation of this type, but now
1243      we're seeing a real definition, we're actually looking at a
1244      partial specialization.  Consider:
1245
1246        template <class T, class U>
1247        struct Y {};
1248
1249        template <class T>
1250        struct X {};
1251
1252        template <class T, class U>
1253        void f()
1254        {
1255          typename X<Y<T, U> >::A a;
1256        }
1257
1258        template <class T, class U>
1259        struct X<Y<T, U> >
1260        {
1261        };
1262
1263      We have to undo the effects of the previous partial
1264      instantiation.  */
1265   if (PARTIAL_INSTANTIATION_P (t))
1266     {
1267       if (!pedantic)
1268         {
1269           /* Unfortunately, when we're not in pedantic mode, we
1270              attempt to actually fill in some of the fields of the
1271              partial instantiation, in order to support the implicit
1272              typename extension.  Clear those fields now, in
1273              preparation for the definition here.  The fields cleared
1274              here must match those set in instantiate_class_template.
1275              Look for a comment mentioning begin_class_definition
1276              there.  */
1277           TYPE_BINFO_BASETYPES (t) = NULL_TREE;
1278           TYPE_FIELDS (t) = NULL_TREE;
1279           TYPE_METHODS (t) = NULL_TREE;
1280           CLASSTYPE_TAGS (t) = NULL_TREE;
1281           TYPE_SIZE (t) = NULL_TREE;
1282         }
1283
1284       /* This isn't a partial instantiation any more.  */
1285       PARTIAL_INSTANTIATION_P (t) = 0;
1286     }
1287   /* If this type was already complete, and we see another definition,
1288      that's an error.  */
1289   else if (TYPE_SIZE (t))
1290     duplicate_tag_error (t);
1291
1292   if (TYPE_BEING_DEFINED (t))
1293     {
1294       t = make_lang_type (TREE_CODE (t));
1295       pushtag (TYPE_IDENTIFIER (t), t, 0);
1296     }
1297   maybe_process_partial_specialization (t);
1298   pushclass (t, 1);
1299   TYPE_BEING_DEFINED (t) = 1;
1300   /* Reset the interface data, at the earliest possible
1301      moment, as it might have been set via a class foo;
1302      before.  */
1303   /* Don't change signatures.  */
1304   if (! IS_SIGNATURE (t))
1305     {
1306       int needs_writing;
1307       tree name = TYPE_IDENTIFIER (t);
1308
1309       if (! ANON_AGGRNAME_P (name))
1310         {
1311           CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1312           SET_CLASSTYPE_INTERFACE_UNKNOWN_X
1313             (t, interface_unknown);
1314         }
1315
1316       /* Record how to set the access of this class's
1317          virtual functions.  If write_virtuals == 3, then
1318          inline virtuals are ``extern inline''.  */
1319       if (write_virtuals == 3)
1320         needs_writing = ! CLASSTYPE_INTERFACE_ONLY (t)
1321           && CLASSTYPE_INTERFACE_KNOWN (t);
1322       else
1323         needs_writing = 1;
1324       CLASSTYPE_VTABLE_NEEDS_WRITING (t) = needs_writing;
1325     }
1326 #if 0
1327   tmp = TYPE_IDENTIFIER ($<ttype>0);
1328   if (tmp && IDENTIFIER_TEMPLATE (tmp))
1329     overload_template_name (tmp, 1);
1330 #endif
1331   reset_specialization();
1332
1333   /* In case this is a local class within a template
1334      function, we save the current tree structure so
1335      that we can get it back later.  */
1336   begin_tree ();
1337
1338   /* Make a declaration for this class in its own scope.  */
1339   build_self_reference ();
1340
1341   return t;
1342 }
1343
1344 /* Finish the member declaration given by DECL.  */
1345
1346 void
1347 finish_member_declaration (decl)
1348      tree decl;
1349 {
1350   if (decl == error_mark_node || decl == NULL_TREE)
1351     return;
1352
1353   if (decl == void_type_node)
1354     /* The COMPONENT was a friend, not a member, and so there's
1355        nothing for us to do.  */
1356     return;
1357
1358   /* We should see only one DECL at a time.  */
1359   my_friendly_assert (TREE_CHAIN (decl) == NULL_TREE, 0);
1360
1361   /* Set up access control for DECL.  */
1362   TREE_PRIVATE (decl)
1363     = (current_access_specifier == access_private_node);
1364   TREE_PROTECTED (decl)
1365     = (current_access_specifier == access_protected_node);
1366   if (TREE_CODE (decl) == TEMPLATE_DECL)
1367     {
1368       TREE_PRIVATE (DECL_RESULT (decl)) = TREE_PRIVATE (decl);
1369       TREE_PROTECTED (DECL_RESULT (decl)) = TREE_PROTECTED (decl);
1370     }
1371
1372   /* Mark the DECL as a member of the current class.  */
1373   if (TREE_CODE (decl) == FUNCTION_DECL
1374       || DECL_FUNCTION_TEMPLATE_P (decl))
1375     /* Historically, DECL_CONTEXT was not set for a FUNCTION_DECL in
1376        finish_struct.  Presumably it is already set as the function is
1377        parsed.  Perhaps DECL_CLASS_CONTEXT is already set, too?  */
1378     DECL_CLASS_CONTEXT (decl) = current_class_type;
1379   else
1380     DECL_CONTEXT (decl) = current_class_type;
1381
1382   /* Put functions on the TYPE_METHODS list and everything else on the
1383      TYPE_FIELDS list.  Note that these are built up in reverse order.
1384      We reverse them (to obtain declaration order) in finish_struct.  */
1385   if (TREE_CODE (decl) == FUNCTION_DECL
1386       || DECL_FUNCTION_TEMPLATE_P (decl))
1387     {
1388       /* We also need to add this function to the
1389          CLASSTYPE_METHOD_VEC.  */
1390       add_method (current_class_type, 0, decl);
1391
1392       TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
1393       TYPE_METHODS (current_class_type) = decl;
1394     }
1395   else
1396     {
1397       /* All TYPE_DECLs go at the end of TYPE_FIELDS.  Ordinary fields
1398          go at the beginning.  The reason is that lookup_field_1
1399          searches the list in order, and we want a field name to
1400          override a type name so that the "struct stat hack" will
1401          work.  In particular:
1402
1403            struct S { enum E { }; int E } s;
1404            s.E = 3;
1405
1406          is legal.  In addition, the FIELD_DECLs must be maintained in
1407          declaration order so that class layout works as expected.
1408          However, we don't need that order until class layout, so we
1409          save a little time by putting FIELD_DECLs on in reverse order
1410          here, and then reversing them in finish_struct_1.  (We could
1411          also keep a pointer to the correct insertion points in the
1412          list.)  */
1413
1414       if (TREE_CODE (decl) == TYPE_DECL)
1415         TYPE_FIELDS (current_class_type)
1416           = chainon (TYPE_FIELDS (current_class_type), decl);
1417       else
1418         {
1419           TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
1420           TYPE_FIELDS (current_class_type) = decl;
1421         }
1422
1423       /* Enter the DECL into the scope of the class.  */
1424       if (TREE_CODE (decl) != USING_DECL)
1425         pushdecl_class_level (decl);
1426     }
1427 }
1428
1429 /* Finish a class definition T with the indicate ATTRIBUTES.  If SEMI,
1430    the definition is immediately followed by a semicolon.  Returns the
1431    type.  */
1432
1433 tree
1434 finish_class_definition (t, attributes, semi, pop_scope_p)
1435      tree t;
1436      tree attributes;
1437      int semi;
1438      int pop_scope_p;
1439 {
1440   /* finish_struct nukes this anyway; if finish_exception does too,
1441      then it can go.  */
1442   if (semi)
1443     note_got_semicolon (t);
1444
1445   /* If we got any attributes in class_head, xref_tag will stick them in
1446      TREE_TYPE of the type.  Grab them now.  */
1447   attributes = chainon (TREE_TYPE (t), attributes);
1448   TREE_TYPE (t) = NULL_TREE;
1449
1450   if (TREE_CODE (t) == ENUMERAL_TYPE)
1451     ;
1452   else
1453     {
1454       t = finish_struct (t, attributes, semi);
1455       if (semi)
1456         note_got_semicolon (t);
1457     }
1458
1459   pop_obstacks ();
1460
1461   if (! semi)
1462     check_for_missing_semicolon (t);
1463   if (pop_scope_p)
1464     pop_scope (CP_DECL_CONTEXT (TYPE_MAIN_DECL (t)));
1465   if (current_scope () == current_function_decl)
1466     do_pending_defargs ();
1467
1468   return t;
1469 }
1470
1471 /* Finish processing the default argument expressions cached during
1472    the processing of a class definition.  */
1473
1474 void
1475 begin_inline_definitions ()
1476 {
1477   if (pending_inlines
1478       && current_scope () == current_function_decl)
1479     do_pending_inlines ();
1480 }
1481
1482 /* Finish processing the inline function definitions cached during the
1483    processing of a class definition.  */
1484
1485 void
1486 finish_inline_definitions ()
1487 {
1488   if (current_class_type == NULL_TREE)
1489     clear_inline_text_obstack ();
1490
1491   /* Undo the begin_tree in begin_class_definition.  */
1492   end_tree ();
1493 }
1494
1495 /* Finish processing the declaration of a member class template
1496    TYPES whose template parameters are given by PARMS.  */
1497
1498 tree
1499 finish_member_class_template (types)
1500      tree types;
1501 {
1502   tree t;
1503
1504   /* If there are declared, but undefined, partial specializations
1505      mixed in with the typespecs they will not yet have passed through
1506      maybe_process_partial_specialization, so we do that here.  */
1507   for (t = types; t != NULL_TREE; t = TREE_CHAIN (t))
1508     if (IS_AGGR_TYPE_CODE (TREE_CODE (TREE_VALUE (t))))
1509       maybe_process_partial_specialization (TREE_VALUE (t));
1510
1511   note_list_got_semicolon (types);
1512   grok_x_components (types);
1513   if (TYPE_CONTEXT (TREE_VALUE (types)) != current_class_type)
1514     /* The component was in fact a friend declaration.  We avoid
1515        finish_member_template_decl performing certain checks by
1516        unsetting TYPES.  */
1517     types = NULL_TREE;
1518
1519   finish_member_template_decl (types);
1520
1521   /* As with other component type declarations, we do
1522      not store the new DECL on the list of
1523      component_decls.  */
1524   return NULL_TREE;
1525 }
1526
1527 /* Finish processsing a complete template declaration.  The PARMS are
1528    the template parameters.  */
1529
1530 void
1531 finish_template_decl (parms)
1532      tree parms;
1533 {
1534   if (parms)
1535     end_template_decl ();
1536   else
1537     end_specialization ();
1538 }
1539
1540 /* Finish processing a a template-id (which names a type) of the form
1541    NAME < ARGS >.  Return the TYPE_DECL for the type named by the
1542    template-id.  If ENTERING_SCOPE is non-zero we are about to enter
1543    the scope of template-id indicated.  */
1544
1545 tree
1546 finish_template_type (name, args, entering_scope)
1547      tree name;
1548      tree args;
1549      int entering_scope;
1550 {
1551   tree decl;
1552
1553   decl = lookup_template_class (name, args,
1554                                 NULL_TREE, NULL_TREE, entering_scope);
1555   if (decl != error_mark_node)
1556     decl = TYPE_STUB_DECL (decl);
1557
1558   return decl;
1559 }
1560
1561 /* SR is a SCOPE_REF node.  Enter the scope of SR, whether it is a
1562    namespace scope or a class scope.  */
1563
1564 void
1565 enter_scope_of (sr)
1566      tree sr;
1567 {
1568   tree scope = TREE_OPERAND (sr, 0);
1569
1570   if (TREE_CODE (scope) == NAMESPACE_DECL)
1571     {
1572       push_decl_namespace (scope);
1573       TREE_COMPLEXITY (sr) = -1;
1574     }
1575   else if (scope != current_class_type)
1576     {
1577       if (TREE_CODE (scope) == TYPENAME_TYPE)
1578         {
1579           /* In a declarator for a template class member, the scope will
1580              get here as an implicit typename, a TYPENAME_TYPE with a type.  */
1581           scope = TREE_TYPE (scope);
1582           TREE_OPERAND (sr, 0) = scope;
1583         }
1584       push_nested_class (scope, 3);
1585       TREE_COMPLEXITY (sr) = current_class_depth;
1586     }
1587 }
1588
1589 /* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
1590    Return a TREE_LIST containing the ACCESS_SPECIFIER and the
1591    BASE_CLASS, or NULL_TREE if an error occurred.  The
1592    ACCESSS_SPECIFIER is one of
1593    access_{default,public,protected_private}[_virtual]_node.*/
1594
1595 tree
1596 finish_base_specifier (access_specifier, base_class,
1597                        current_aggr_is_signature)
1598      tree access_specifier;
1599      tree base_class;
1600      int current_aggr_is_signature;
1601 {
1602   tree type;
1603   tree result;
1604
1605   if (base_class == NULL_TREE)
1606     {
1607       error ("invalid base class");
1608       type = error_mark_node;
1609     }
1610   else
1611     type = TREE_TYPE (base_class);
1612   if (current_aggr_is_signature && access_specifier)
1613     error ("access and source specifiers not allowed in signature");
1614   if (! is_aggr_type (type, 1))
1615     result = NULL_TREE;
1616   else if (current_aggr_is_signature
1617            && (! type) && (! IS_SIGNATURE (type)))
1618     {
1619       error ("class name not allowed as base signature");
1620       result = NULL_TREE;
1621     }
1622   else if (current_aggr_is_signature)
1623     {
1624       sorry ("signature inheritance, base type `%s' ignored",
1625              IDENTIFIER_POINTER (access_specifier));
1626       result = build_tree_list (access_public_node, type);
1627     }
1628   else if (type && IS_SIGNATURE (type))
1629     {
1630       error ("signature name not allowed as base class");
1631       result = NULL_TREE;
1632     }
1633   else
1634     result = build_tree_list (access_specifier, type);
1635
1636   return result;
1637 }
1638
1639 /* Called when multiple declarators are processed.  If that is not
1640    premitted in this context, an error is issued.  */
1641
1642 void
1643 check_multiple_declarators ()
1644 {
1645   /* [temp]
1646
1647      In a template-declaration, explicit specialization, or explicit
1648      instantiation the init-declarator-list in the declaration shall
1649      contain at most one declarator.
1650
1651      We don't just use PROCESSING_TEMPLATE_DECL for the first
1652      condition since that would disallow the perfectly legal code,
1653      like `template <class T> struct S { int i, j; };'.  */
1654   tree scope = current_scope ();
1655
1656   if (scope && TREE_CODE (scope) == FUNCTION_DECL)
1657     /* It's OK to write `template <class T> void f() { int i, j;}'.  */
1658     return;
1659
1660   if (PROCESSING_REAL_TEMPLATE_DECL_P ()
1661       || processing_explicit_instantiation
1662       || processing_specialization)
1663     cp_error ("multiple declarators in template declaration");
1664 }
1665
1666 tree
1667 finish_typeof (expr)
1668      tree expr;
1669 {
1670   if (processing_template_decl)
1671     {
1672       tree t;
1673
1674       push_obstacks_nochange ();
1675       end_temporary_allocation ();
1676
1677       t = make_lang_type (TYPEOF_TYPE);
1678       TYPE_FIELDS (t) = expr;
1679
1680       pop_obstacks ();
1681
1682       return t;
1683     }
1684
1685   return TREE_TYPE (expr);
1686 }