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 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) = 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) = 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) = 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) = 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
 494     {
 495       emit_line_note (input_filename, lineno);
 496       c_expand_start_case (cond);
 497       r = NULL_TREE;
 498     }
 499   push_switch ();
 500
 501   /* Don't let the tree nodes for COND be discarded by
 502      clear_momentary during the parsing of the next stmt.  */
 503   push_momentary ();
 504
 505   return r;
 506 }
 507
 508 /* Finish the body of a switch-statement, which may be given by
 509    SWITCH_STMT.  The COND to switch on is indicated.  */
 510
 511 void
 512 finish_switch_stmt (cond, switch_stmt)
 513      tree cond;
 514      tree switch_stmt;
 515 {
 516   if (processing_template_decl)
 517     RECHAIN_STMTS_FROM_CHAIN (switch_stmt, SWITCH_BODY (switch_stmt));
 518   else
 519     expand_end_case (cond);
 520   pop_momentary ();
 521   pop_switch ();
 522   do_poplevel ();
 523   finish_stmt ();
 524 }
 525
 526 /* Finish a case-label.  */
 527
 528 void
 529 finish_case_label (low_value, high_value)
 530      tree low_value;
 531      tree high_value;
 532 {
 533   do_case (low_value, high_value);
 534 }
 535
 536
 537 /* Finish a goto-statement.  */
 538
 539 void
 540 finish_goto_stmt (destination)
 541      tree destination;
 542 {
 543   if (processing_template_decl)
 544     add_tree (build_min_nt (GOTO_STMT, destination));
 545   else
 546     {
 547       emit_line_note (input_filename, lineno);
 548
 549       if (TREE_CODE (destination) == IDENTIFIER_NODE)
 550         {
 551           tree decl = lookup_label (destination);
 552           TREE_USED (decl) = 1;
 553           expand_goto (decl);
 554         }
 555       else
 556         expand_computed_goto (destination);
 557     }
 558 }
 559
 560 /* Begin a try-block.  Returns a newly-created TRY_BLOCK if
 561    appropriate.  */
 562
 563 tree
 564 begin_try_block ()
 565 {
 566   if (processing_template_decl)
 567     {
 568       tree r = build_min_nt (TRY_BLOCK, NULL_TREE,
 569                              NULL_TREE);
 570       add_tree (r);
 571       return r;
 572     }
 573   else
 574     {
 575       emit_line_note (input_filename, lineno);
 576       expand_start_try_stmts ();
 577       return NULL_TREE;
 578     }
 579 }
 580
 581 /* Finish a try-block, which may be given by TRY_BLOCK.  */
 582
 583 void
 584 finish_try_block (try_block)
 585      tree try_block;
 586 {
 587   if (processing_template_decl)
 588     RECHAIN_STMTS_FROM_LAST (try_block, TRY_STMTS (try_block));
 589   else
 590     {
 591       expand_start_all_catch ();
 592       expand_start_catch (NULL);
 593     }
 594 }
 595
 596 /* Finish a handler-sequence for a try-block, which may be given by
 597    TRY_BLOCK.  */
 598
 599 void
 600 finish_handler_sequence (try_block)
 601      tree try_block;
 602 {
 603   if (processing_template_decl)
 604     RECHAIN_STMTS_FROM_CHAIN (try_block, TRY_HANDLERS (try_block));
 605   else
 606     {
 607       expand_end_catch ();
 608       expand_end_all_catch ();
 609     }
 610 }
 611
 612 /* Begin a handler.  Returns a HANDLER if appropriate.  */
 613
 614 tree
 615 begin_handler ()
 616 {
 617   tree r;
 618
 619   if (processing_template_decl)
 620     {
 621       r = build_min_nt (HANDLER, NULL_TREE, NULL_TREE);
 622       add_tree (r);
 623     }
 624   else
 625     r = NULL_TREE;
 626
 627   do_pushlevel ();
 628
 629   return r;
 630 }
 631
 632 /* Finish the handler-parameters for a handler, which may be given by
 633    HANDLER.  */
 634
 635 void
 636 finish_handler_parms (handler)
 637      tree handler;
 638 {
 639   if (processing_template_decl)
 640     RECHAIN_STMTS_FROM_CHAIN (handler, HANDLER_PARMS (handler));
 641 }
 642
 643 /* Finish a handler, which may be given by HANDLER.  */
 644
 645 void
 646 finish_handler (handler)
 647      tree handler;
 648 {
 649   if (processing_template_decl)
 650     RECHAIN_STMTS_FROM_CHAIN (handler, HANDLER_BODY (handler));
 651   else
 652     expand_end_catch_block ();
 653
 654   do_poplevel ();
 655 }
 656
 657 /* Begin a compound-statement.  If HAS_NO_SCOPE is non-zero, the
 658    compound-statement does not define a scope.  Returns a new
 659    COMPOUND_STMT if appropriate.  */
 660
 661 tree
 662 begin_compound_stmt (has_no_scope)
 663      int has_no_scope;
 664 {
 665   tree r;
 666
 667   if (processing_template_decl)
 668     {
 669       r = build_min_nt (COMPOUND_STMT, NULL_TREE);
 670       add_tree (r);
 671       if (has_no_scope)
 672         COMPOUND_STMT_NO_SCOPE (r) = 1;
 673     }
 674   else
 675     r = NULL_TREE;
 676
 677   if (!has_no_scope)
 678     do_pushlevel ();
 679
 680   return r;
 681 }
 682
 683
 684 /* Finish a compound-statement, which may be given by COMPOUND_STMT.
 685    If HAS_NO_SCOPE is non-zero, the compound statement does not define
 686    a scope.  */
 687
 688 tree
 689 finish_compound_stmt (has_no_scope, compound_stmt)
 690      int has_no_scope;
 691      tree compound_stmt;
 692 {
 693   tree r;
 694
 695   if (!has_no_scope)
 696     r = do_poplevel ();
 697   else
 698     r = NULL_TREE;
 699
 700   if (processing_template_decl)
 701     RECHAIN_STMTS_FROM_CHAIN (compound_stmt,
 702                               COMPOUND_BODY (compound_stmt));
 703
 704   finish_stmt ();
 705
 706   return r;
 707 }
 708
 709 /* Finish an asm-statement, whose components are a CV_QUALIFIER, a
 710    STRING, some OUTPUT_OPERANDS, some INPUT_OPERANDS, and some
 711    CLOBBERS.  */
 712
 713 void
 714 finish_asm_stmt (cv_qualifier, string, output_operands,
 715                       input_operands, clobbers)
 716      tree cv_qualifier;
 717      tree string;
 718      tree output_operands;
 719      tree input_operands;
 720      tree clobbers;
 721 {
 722   if (TREE_CHAIN (string))
 723     string = combine_strings (string);
 724
 725   if (processing_template_decl)
 726     {
 727       tree r = build_min_nt (ASM_STMT, cv_qualifier, string,
 728                              output_operands, input_operands,
 729                              clobbers);
 730       add_tree (r);
 731     }
 732   else
 733     {
 734       emit_line_note (input_filename, lineno);
 735       if (output_operands != NULL_TREE || input_operands != NULL_TREE
 736           || clobbers != NULL_TREE)
 737         {
 738           if (cv_qualifier != NULL_TREE
 739               && cv_qualifier != ridpointers[(int) RID_VOLATILE])
 740             cp_warning ("%s qualifier ignored on asm",
 741                         IDENTIFIER_POINTER (cv_qualifier));
 742
 743           c_expand_asm_operands (string, output_operands,
 744                                  input_operands,
 745                                  clobbers,
 746                                  cv_qualifier
 747                                  == ridpointers[(int) RID_VOLATILE],
 748                                  input_filename, lineno);
 749         }
 750       else
 751         {
 752           if (cv_qualifier != NULL_TREE)
 753             cp_warning ("%s qualifier ignored on asm",
 754                         IDENTIFIER_POINTER (cv_qualifier));
 755           expand_asm (string);
 756         }
 757
 758       finish_stmt ();
 759     }
 760 }
 761
 762 /* Finish a parenthesized expression EXPR.  */
 763
 764 tree
 765 finish_parenthesized_expr (expr)
 766      tree expr;
 767 {
 768   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expr))))
 769     /* This inhibits warnings in truthvalue_conversion.  */
 770     C_SET_EXP_ORIGINAL_CODE (expr, ERROR_MARK);
 771
 772   return expr;
 773 }
 774
 775 /* Begin a statement-expression.  The value returned must be passed to
 776    finish_stmt_expr.  */
 777
 778 tree
 779 begin_stmt_expr ()
 780 {
 781   keep_next_level ();
 782   /* If we're processing_template_decl, then the upcoming compound
 783      statement will be chained onto the tree structure, starting at
 784      last_tree.  We return last_tree so that we can later unhook the
 785      compound statement.  */
 786   return processing_template_decl ? last_tree : expand_start_stmt_expr();
 787 }
 788
 789 /* Finish a statement-expression.  RTL_EXPR should be the value
 790    returned by the previous begin_stmt_expr; EXPR is the
 791    statement-expression.  Returns an expression representing the
 792    statement-expression.  */
 793
 794 tree
 795 finish_stmt_expr (rtl_expr, expr)
 796      tree rtl_expr;
 797      tree expr;
 798 {
 799   tree result;
 800
 801   if (!processing_template_decl)
 802     {
 803       rtl_expr = expand_end_stmt_expr (rtl_expr);
 804       /* The statements have side effects, so the group does.  */
 805       TREE_SIDE_EFFECTS (rtl_expr) = 1;
 806     }
 807
 808   if (TREE_CODE (expr) == BLOCK)
 809     {
 810       /* Make a BIND_EXPR for the BLOCK already made.  */
 811       if (processing_template_decl)
 812         result = build (BIND_EXPR, NULL_TREE,
 813                         NULL_TREE, last_tree, expr);
 814       else
 815         result = build (BIND_EXPR, TREE_TYPE (rtl_expr),
 816                         NULL_TREE, rtl_expr, expr);
 817
 818       /* Remove the block from the tree at this point.
 819          It gets put back at the proper place
 820          when the BIND_EXPR is expanded.  */
 821       delete_block (expr);
 822     }
 823   else
 824     result = expr;
 825
 826   if (processing_template_decl)
 827     {
 828       /* Remove the compound statement from the tree structure; it is
 829          now saved in the BIND_EXPR.  */
 830       last_tree = rtl_expr;
 831       TREE_CHAIN (last_tree) = NULL_TREE;
 832     }
 833
 834   return result;
 835 }
 836
 837 /* Finish a call to FN with ARGS.  Returns a representation of the
 838    call.  */
 839
 840 tree
 841 finish_call_expr (fn, args)
 842      tree fn;
 843      tree args;
 844 {
 845   tree result = build_x_function_call (fn, args, current_class_ref);
 846
 847   if (TREE_CODE (result) == CALL_EXPR
 848       && TREE_TYPE (result) != void_type_node)
 849     result = require_complete_type (result);
 850
 851   return result;
 852 }
 853
 854 /* Finish a call to a postfix increment or decrement or EXPR.  (Which
 855    is indicated by CODE, which should be POSTINCREMENT_EXPR or
 856    POSTDECREMENT_EXPR.)  */
 857
 858 tree
 859 finish_increment_expr (expr, code)
 860      tree expr;
 861      enum tree_code code;
 862 {
 863   /* If we get an OFFSET_REF, turn it into what it really means (e.g.,
 864      a COMPONENT_REF).  This way if we've got, say, a reference to a
 865      static member that's being operated on, we don't end up trying to
 866      find a member operator for the class it's in.  */
 867
 868   if (TREE_CODE (expr) == OFFSET_REF)
 869     expr = resolve_offset_ref (expr);
 870   return build_x_unary_op (code, expr);
 871 }
 872
 873 /* Finish a use of `this'.  Returns an expression for `this'.  */
 874
 875 tree
 876 finish_this_expr ()
 877 {
 878   tree result;
 879
 880   if (current_class_ptr)
 881     {
 882 #ifdef WARNING_ABOUT_CCD
 883       TREE_USED (current_class_ptr) = 1;
 884 #endif
 885       result = current_class_ptr;
 886     }
 887   else if (current_function_decl
 888            && DECL_STATIC_FUNCTION_P (current_function_decl))
 889     {
 890       error ("`this' is unavailable for static member functions");
 891       result = error_mark_node;
 892     }
 893   else
 894     {
 895       if (current_function_decl)
 896         error ("invalid use of `this' in non-member function");
 897       else
 898         error ("invalid use of `this' at top level");
 899       result = error_mark_node;
 900     }
 901
 902   return result;
 903 }
 904
 905 /* Finish a member function call using OBJECT and ARGS as arguments to
 906    FN.  Returns an expression for the call.  */
 907
 908 tree
 909 finish_object_call_expr (fn, object, args)
 910      tree fn;
 911      tree object;
 912      tree args;
 913 {
 914 #if 0
 915   /* This is a future direction of this code, but because
 916      build_x_function_call cannot always undo what is done in
 917      build_component_ref entirely yet, we cannot do this.  */
 918
 919   tree real_fn = build_component_ref (object, fn, NULL_TREE, 1);
 920   return finish_call_expr (real_fn, args);
 921 #else
 922   if (TREE_CODE (fn) == TYPE_DECL)
 923     {
 924       cp_error ("calling type `%T' like a method", fn);
 925       return error_mark_node;
 926     }
 927
 928   return build_method_call (object, fn, args, NULL_TREE, LOOKUP_NORMAL);
 929 #endif
 930 }
 931
 932 /* Finish a qualified member function call using OBJECT and ARGS as
 933    arguments to FN.  Returns an expressino for the call.  */
 934
 935 tree
 936 finish_qualified_object_call_expr (fn, object, args)
 937      tree fn;
 938      tree object;
 939      tree args;
 940 {
 941   if (IS_SIGNATURE (TREE_OPERAND (fn, 0)))
 942     {
 943       warning ("signature name in scope resolution ignored");
 944       return finish_object_call_expr (TREE_OPERAND (fn, 1), object, args);
 945     }
 946   else
 947     return build_scoped_method_call (object, TREE_OPERAND (fn, 0),
 948                                      TREE_OPERAND (fn, 1), args);
 949 }
 950
 951 /* Finish a pseudo-destructor call expression of OBJECT, with SCOPE
 952    being the scope, if any, of DESTRUCTOR.  Returns an expression for
 953    the call.  */
 954
 955 tree
 956 finish_pseudo_destructor_call_expr (object, scope, destructor)
 957      tree object;
 958      tree scope;
 959      tree destructor;
 960 {
 961   if (scope && scope != destructor)
 962     cp_error ("destructor specifier `%T::~%T()' must have matching names",
 963               scope, destructor);
 964
 965   if ((scope == NULL_TREE || IDENTIFIER_GLOBAL_VALUE (destructor))
 966       && (TREE_CODE (TREE_TYPE (object)) !=
 967           TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (destructor)))))
 968     cp_error ("`%E' is not of type `%T'", object, destructor);
 969
 970   return cp_convert (void_type_node, object);
 971 }
 972
 973 /* Finish a call to a globally qualified member function FN using
 974    ARGS.  Returns an expression for the call.  */
 975
 976 tree
 977 finish_globally_qualified_member_call_expr (fn, args)
 978      tree fn;
 979      tree args;
 980 {
 981   if (processing_template_decl)
 982     return build_min_nt (CALL_EXPR, copy_to_permanent (fn), args,
 983                          NULL_TREE);
 984   else
 985     return build_member_call (TREE_OPERAND (fn, 0),
 986                               TREE_OPERAND (fn, 1),
 987                               args);
 988 }
 989
 990 /* Finish an expression taking the address of LABEL.  Returns an
 991    expression for the address.  */
 992
 993 tree
 994 finish_label_address_expr (label)
 995      tree label;
 996 {
 997   tree result;
 998
 999   label = lookup_label (label);
1000   if (label == NULL_TREE)
1001     result = null_pointer_node;
1002   else
1003     {
1004       TREE_USED (label) = 1;
1005       result = build1 (ADDR_EXPR, ptr_type_node, label);
1006       TREE_CONSTANT (result) = 1;
1007     }
1008
1009   return result;
1010 }
1011
1012 /* Finish an expression of the form CODE EXPR.  */
1013
1014 tree
1015 finish_unary_op_expr (code, expr)
1016      enum tree_code code;
1017      tree expr;
1018 {
1019   tree result = build_x_unary_op (code, expr);
1020   if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST)
1021     TREE_NEGATED_INT (result) = 1;
1022   overflow_warning (result);
1023   return result;
1024 }
1025
1026 /* Finish an id-expression.  */
1027
1028 tree
1029 finish_id_expr (expr)
1030      tree expr;
1031 {
1032   if (TREE_CODE (expr) == IDENTIFIER_NODE)
1033     expr = do_identifier (expr, 1);
1034
1035   return expr;
1036 }
1037
1038 /* Begin a new-placement.  */
1039
1040 int
1041 begin_new_placement ()
1042 {
1043   /* The arguments to a placement new might be passed to a
1044      deallocation function, in the event that the allocation throws an
1045      exception.  Since we don't expand exception handlers until the
1046      end of a function, we must make sure the arguments stay around
1047      that long.  */
1048   return suspend_momentary ();
1049 }
1050
1051 /* Finish a new-placement.  The ARGS are the placement arguments.  The
1052    COOKIE is the value returned by the previous call to
1053    begin_new_placement.  */
1054
1055 tree
1056 finish_new_placement (args, cookie)
1057      tree args;
1058      int cookie;
1059 {
1060   resume_momentary (cookie);
1061   return args;
1062 }
1063
1064 /* Begin a function defniition declared with DECL_SPECS and
1065    DECLARATOR.  Returns non-zero if the function-declaration is
1066    legal.  */
1067
1068 int
1069 begin_function_definition (decl_specs, declarator)
1070      tree decl_specs;
1071      tree declarator;
1072 {
1073   tree specs;
1074   tree attrs;
1075   split_specs_attrs (decl_specs, &specs, &attrs);
1076   if (!start_function (specs, declarator, attrs, 0))
1077     return 0;
1078
1079   reinit_parse_for_function ();
1080   return 1;
1081 }
1082
1083 /* Begin a constructor declarator of the form `SCOPE::NAME'.  Returns
1084    a SCOPE_REF.  */
1085
1086 tree
1087 begin_constructor_declarator (scope, name)
1088      tree scope;
1089      tree name;
1090 {
1091   tree result = build_parse_node (SCOPE_REF, scope, name);
1092
1093   if (scope != current_class_type)
1094     {
1095       push_nested_class (scope, 3);
1096       TREE_COMPLEXITY (result) = current_class_depth;
1097     }
1098
1099   return result;
1100 }
1101
1102 /* Finish an init-declarator.  Returns a DECL.  */
1103
1104 tree
1105 finish_declarator (declarator, declspecs, attributes,
1106                    prefix_attributes, initialized)
1107      tree declarator;
1108      tree declspecs;
1109      tree attributes;
1110      tree prefix_attributes;
1111      int initialized;
1112 {
1113   return start_decl (declarator, declspecs, initialized, attributes,
1114                      prefix_attributes);
1115 }
1116
1117 /* Finish a transltation unit.  */
1118
1119 void
1120 finish_translation_unit ()
1121 {
1122   /* In case there were missing closebraces,
1123      get us back to the global binding level.  */
1124   while (! toplevel_bindings_p ())
1125     poplevel (0, 0, 0);
1126   while (current_namespace != global_namespace)
1127     pop_namespace ();
1128   finish_file ();
1129 }
1130
1131 /* Finish a template type parameter, specified as AGGR IDENTIFIER.
1132    Returns the parameter.  */
1133
1134 tree
1135 finish_template_type_parm (aggr, identifier)
1136      tree aggr;
1137      tree identifier;
1138 {
1139   if (aggr == signature_type_node)
1140     sorry ("signature as template type parameter");
1141   else if (aggr != class_type_node)
1142     {
1143       pedwarn ("template type parameters must use the keyword `class' or `typename'");
1144       aggr = class_type_node;
1145     }
1146
1147   return build_tree_list (aggr, identifier);
1148 }
1149
1150 /* Finish a template template parameter, specified as AGGR IDENTIFIER.
1151    Returns the parameter.  */
1152
1153 tree
1154 finish_template_template_parm (aggr, identifier)
1155      tree aggr;
1156      tree identifier;
1157 {
1158   tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
1159   tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
1160   DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
1161   DECL_TEMPLATE_RESULT (tmpl) = decl;
1162   SET_DECL_ARTIFICIAL (decl);
1163   end_template_decl ();
1164
1165   return finish_template_type_parm (aggr, tmpl);
1166 }
1167
1168 /* Finish a parameter list, indicated by PARMS.  If ELLIPSIS is
1169    non-zero, the parameter list was terminated by a `...'.  */
1170
1171 tree
1172 finish_parmlist (parms, ellipsis)
1173      tree parms;
1174      int ellipsis;
1175 {
1176   if (!ellipsis)
1177     chainon (parms, void_list_node);
1178   /* We mark the PARMS as a parmlist so that declarator processing can
1179      disambiguate certain constructs.  */
1180   if (parms != NULL_TREE)
1181     TREE_PARMLIST (parms) = 1;
1182
1183   return parms;
1184 }
1185
1186 /* Begin a class definition, as indicated by T.  */
1187
1188 tree
1189 begin_class_definition (t)
1190      tree t;
1191 {
1192   tree new_type = t;
1193
1194   push_obstacks_nochange ();
1195   end_temporary_allocation ();
1196
1197   if (t == error_mark_node
1198       || ! IS_AGGR_TYPE (t))
1199     {
1200       t = new_type = make_lang_type (RECORD_TYPE);
1201       pushtag (make_anon_name (), t, 0);
1202     }
1203   if (TYPE_SIZE (t))
1204     duplicate_tag_error (t);
1205   if (TYPE_SIZE (t) || TYPE_BEING_DEFINED (t))
1206     {
1207       t = make_lang_type (TREE_CODE (t));
1208       pushtag (TYPE_IDENTIFIER (t), t, 0);
1209       new_type = t;
1210     }
1211   if (processing_template_decl && TYPE_CONTEXT (t)
1212       && TREE_CODE (TYPE_CONTEXT (t)) != NAMESPACE_DECL
1213       && ! current_class_type)
1214     push_template_decl (TYPE_STUB_DECL (t));
1215   pushclass (t, 0);
1216   TYPE_BEING_DEFINED (t) = 1;
1217   if (IS_AGGR_TYPE (t) && CLASSTYPE_USE_TEMPLATE (t))
1218     {
1219       if (CLASSTYPE_IMPLICIT_INSTANTIATION (t)
1220           && TYPE_SIZE (t) == NULL_TREE)
1221         {
1222           SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t);
1223           if (processing_template_decl)
1224             push_template_decl (TYPE_MAIN_DECL (t));
1225         }
1226       else if (CLASSTYPE_TEMPLATE_INSTANTIATION (t))
1227         cp_error ("specialization after instantiation of `%T'", t);
1228     }
1229   /* Reset the interface data, at the earliest possible
1230      moment, as it might have been set via a class foo;
1231      before.  */
1232   /* Don't change signatures.  */
1233   if (! IS_SIGNATURE (t))
1234     {
1235       extern tree pending_vtables;
1236       int needs_writing;
1237       tree name = TYPE_IDENTIFIER (t);
1238
1239       if (! ANON_AGGRNAME_P (name))
1240         {
1241           CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1242           SET_CLASSTYPE_INTERFACE_UNKNOWN_X
1243             (t, interface_unknown);
1244         }
1245
1246       /* Record how to set the access of this class's
1247          virtual functions.  If write_virtuals == 2 or 3, then
1248          inline virtuals are ``extern inline''.  */
1249       switch (write_virtuals)
1250         {
1251         case 0:
1252         case 1:
1253           needs_writing = 1;
1254           break;
1255         case 2:
1256           needs_writing = !! value_member (name, pending_vtables);
1257           break;
1258         case 3:
1259           needs_writing = ! CLASSTYPE_INTERFACE_ONLY (t)
1260             && CLASSTYPE_INTERFACE_KNOWN (t);
1261           break;
1262         default:
1263           needs_writing = 0;
1264         }
1265       CLASSTYPE_VTABLE_NEEDS_WRITING (t) = needs_writing;
1266     }
1267 #if 0
1268   t = TYPE_IDENTIFIER ($<ttype>0);
1269   if (t && IDENTIFIER_TEMPLATE (t))
1270     overload_template_name (t, 1);
1271 #endif
1272   reset_specialization();
1273
1274   /* In case this is a local class within a template
1275      function, we save the current tree structure so
1276      that we can get it back later.  */
1277   begin_tree ();
1278
1279   return new_type;
1280 }
1281
1282 /* Finish a class definition T, with the indicated COMPONENTS, and
1283    with the indicate ATTRIBUTES.  If SEMI, the definition is
1284    immediately followed by a semicolon.  Returns the type.  */
1285
1286 tree
1287 finish_class_definition (t, components, attributes, semi)
1288      tree t;
1289      tree components;
1290      tree attributes;
1291      int semi;
1292 {
1293 #if 0
1294   /* Need to rework class nesting in the presence of nested classes,
1295      etc.  */
1296   shadow_tag (CLASSTYPE_AS_LIST (t)); */
1297 #endif
1298
1299   /* finish_struct nukes this anyway; if finish_exception does too,
1300      then it can go.  */
1301   if (semi)
1302     note_got_semicolon (t);
1303
1304   if (TREE_CODE (t) == ENUMERAL_TYPE)
1305     ;
1306   else
1307     {
1308       t = finish_struct (t, components, attributes, semi);
1309       if (semi)
1310         note_got_semicolon (t);
1311     }
1312
1313   pop_obstacks ();
1314
1315   if (! semi)
1316     check_for_missing_semicolon (t);
1317   if (current_scope () == current_function_decl)
1318     do_pending_defargs ();
1319
1320   return t;
1321 }
1322
1323 /* Finish processing the default argument expressions cached during
1324    the processing of a class definition.  */
1325
1326 void
1327 finish_default_args ()
1328 {
1329   if (pending_inlines
1330       && current_scope () == current_function_decl)
1331     do_pending_inlines ();
1332 }
1333
1334 /* Finish processing the inline function definitions cached during the
1335    processing of a class definition.  */
1336
1337 void
1338 begin_inline_definitions ()
1339 {
1340   if (current_class_type == NULL_TREE)
1341     clear_inline_text_obstack ();
1342
1343   /* Undo the begin_tree in begin_class_definition.  */
1344   end_tree ();
1345 }
1346
1347 /* Finish processing the declaration of a member class template
1348    TYPES whose template parameters are given by PARMS.  */
1349
1350 tree
1351 finish_member_class_template (parms, types)
1352      tree parms;
1353      tree types;
1354 {
1355   note_list_got_semicolon (types);
1356   grok_x_components (types, NULL_TREE);
1357   if (TYPE_CONTEXT (TREE_VALUE (types)) != current_class_type)
1358     /* The component was in fact a friend declaration.  We avoid
1359        finish_member_template_decl performing certain checks by
1360        unsetting TYPES.  */
1361     types = NULL_TREE;
1362   finish_member_template_decl (parms, types);
1363   /* As with other component type declarations, we do
1364      not store the new DECL on the list of
1365      component_decls.  */
1366   return NULL_TREE;
1367 }