dmd2/statement.h

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2008 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // http://www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 #ifndef DMD_STATEMENT_H
  12 #define DMD_STATEMENT_H
  13
  14 #ifdef __DMC__
  15 #pragma once
  16 #endif /* __DMC__ */
  17
  18 #include "root.h"
  19
  20 #include "arraytypes.h"
  21 #include "dsymbol.h"
  22
  23 struct OutBuffer;
  24 struct Scope;
  25 struct Expression;
  26 struct LabelDsymbol;
  27 struct Identifier;
  28 struct IfStatement;
  29 struct DeclarationStatement;
  30 struct DefaultStatement;
  31 struct VarDeclaration;
  32 struct Condition;
  33 struct Module;
  34 struct Token;
  35 struct InlineCostState;
  36 struct InlineDoState;
  37 struct InlineScanState;
  38 struct ReturnStatement;
  39 struct CompoundStatement;
  40 struct Argument;
  41 struct StaticAssert;
  42 struct AsmStatement;
  43 struct GotoStatement;
  44 struct ScopeStatement;
  45 struct TryCatchStatement;
  46 struct TryFinallyStatement;
  47 struct HdrGenState;
  48 struct InterState;
  49
  50 enum TOK;
  51
  52 // Back end
  53 struct IRState;
  54 struct Blockx;
  55 #if IN_GCC
  56 union tree_node; typedef union tree_node block;
  57 union tree_node; typedef union tree_node elem;
  58 #else
  59 struct block;
  60 struct elem;
  61 #endif
  62 struct code;
  63
  64 /* How a statement exits
  65  */
  66 enum BE
  67 {
  68     BEnone =     0,
  69     BEfallthru = 1,
  70     BEthrow =    2,
  71     BEreturn =   4,
  72     BEgoto =     8,
  73     BEhalt =     0x10,
  74     BEbreak =    0x20,
  75     BEcontinue = 0x40,
  76     BEany = (BEfallthru | BEthrow | BEreturn | BEgoto | BEhalt),
  77 };
  78
  79 struct Statement : Object
  80 {
  81     Loc loc;
  82
  83     Statement(Loc loc);
  84     virtual Statement *syntaxCopy();
  85
  86     void print();
  87     char *toChars();
  88
  89     void error(const char *format, ...);
  90     virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
  91     virtual TryCatchStatement *isTryCatchStatement() { return NULL; }
  92     virtual GotoStatement *isGotoStatement() { return NULL; }
  93     virtual AsmStatement *isAsmStatement() { return NULL; }
  94 #ifdef _DH
  95     int incontract;
  96 #endif
  97     virtual ScopeStatement *isScopeStatement() { return NULL; }
  98     virtual Statement *semantic(Scope *sc);
  99     Statement *semanticScope(Scope *sc, Statement *sbreak, Statement *scontinue);
 100     virtual int hasBreak();
 101     virtual int hasContinue();
 102     virtual int usesEH();
 103     virtual int fallOffEnd();
 104     virtual int blockExit();
 105     virtual int comeFrom();
 106     virtual void scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally);
 107     virtual Statements *flatten(Scope *sc);
 108     virtual Expression *interpret(InterState *istate);
 109
 110     virtual int inlineCost(InlineCostState *ics);
 111     virtual Expression *doInline(InlineDoState *ids);
 112     virtual Statement *inlineScan(InlineScanState *iss);
 113
 114     // Back end
 115     virtual void toIR(IRState *irs);
 116
 117     // Avoid dynamic_cast
 118     virtual DeclarationStatement *isDeclarationStatement() { return NULL; }
 119     virtual CompoundStatement *isCompoundStatement() { return NULL; }
 120     virtual ReturnStatement *isReturnStatement() { return NULL; }
 121     virtual IfStatement *isIfStatement() { return NULL; }
 122 };
 123
 124 struct ExpStatement : Statement
 125 {
 126     Expression *exp;
 127
 128     ExpStatement(Loc loc, Expression *exp);
 129     Statement *syntaxCopy();
 130     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 131     Statement *semantic(Scope *sc);
 132     Expression *interpret(InterState *istate);
 133     int fallOffEnd();
 134     int blockExit();
 135
 136     int inlineCost(InlineCostState *ics);
 137     Expression *doInline(InlineDoState *ids);
 138     Statement *inlineScan(InlineScanState *iss);
 139
 140     void toIR(IRState *irs);
 141 };
 142
 143 struct CompileStatement : Statement
 144 {
 145     Expression *exp;
 146
 147     CompileStatement(Loc loc, Expression *exp);
 148     Statement *syntaxCopy();
 149     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 150     Statement *semantic(Scope *sc);
 151 };
 152
 153 struct DeclarationStatement : ExpStatement
 154 {
 155     // Doing declarations as an expression, rather than a statement,
 156     // makes inlining functions much easier.
 157
 158     DeclarationStatement(Loc loc, Dsymbol *s);
 159     DeclarationStatement(Loc loc, Expression *exp);
 160     Statement *syntaxCopy();
 161     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 162     void scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally);
 163
 164     DeclarationStatement *isDeclarationStatement() { return this; }
 165 };
 166
 167 struct CompoundStatement : Statement
 168 {
 169     Statements *statements;
 170
 171     CompoundStatement(Loc loc, Statements *s);
 172     CompoundStatement(Loc loc, Statement *s1, Statement *s2);
 173     Statement *syntaxCopy();
 174     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 175     Statement *semantic(Scope *sc);
 176     int usesEH();
 177     int blockExit();
 178     int fallOffEnd();
 179     int comeFrom();
 180     Statements *flatten(Scope *sc);
 181     ReturnStatement *isReturnStatement();
 182     Expression *interpret(InterState *istate);
 183
 184     int inlineCost(InlineCostState *ics);
 185     Expression *doInline(InlineDoState *ids);
 186     Statement *inlineScan(InlineScanState *iss);
 187
 188     void toIR(IRState *irs);
 189
 190     CompoundStatement *isCompoundStatement() { return this; }
 191 };
 192
 193 /* The purpose of this is so that continue will go to the next
 194  * of the statements, and break will go to the end of the statements.
 195  */
 196 struct UnrolledLoopStatement : Statement
 197 {
 198     Statements *statements;
 199
 200     UnrolledLoopStatement(Loc loc, Statements *statements);
 201     Statement *syntaxCopy();
 202     Statement *semantic(Scope *sc);
 203     int hasBreak();
 204     int hasContinue();
 205     int usesEH();
 206     int blockExit();
 207     int fallOffEnd();
 208     int comeFrom();
 209     Expression *interpret(InterState *istate);
 210     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 211
 212     int inlineCost(InlineCostState *ics);
 213     Expression *doInline(InlineDoState *ids);
 214     Statement *inlineScan(InlineScanState *iss);
 215
 216     void toIR(IRState *irs);
 217 };
 218
 219 struct ScopeStatement : Statement
 220 {
 221     Statement *statement;
 222
 223     ScopeStatement(Loc loc, Statement *s);
 224     Statement *syntaxCopy();
 225     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 226     ScopeStatement *isScopeStatement() { return this; }
 227     Statement *semantic(Scope *sc);
 228     int hasBreak();
 229     int hasContinue();
 230     int usesEH();
 231     int blockExit();
 232     int fallOffEnd();
 233     int comeFrom();
 234     Expression *interpret(InterState *istate);
 235
 236     Statement *inlineScan(InlineScanState *iss);
 237
 238     void toIR(IRState *irs);
 239 };
 240
 241 struct WhileStatement : Statement
 242 {
 243     Expression *condition;
 244     Statement *body;
 245
 246     WhileStatement(Loc loc, Expression *c, Statement *b);
 247     Statement *syntaxCopy();
 248     Statement *semantic(Scope *sc);
 249     int hasBreak();
 250     int hasContinue();
 251     int usesEH();
 252     int blockExit();
 253     int fallOffEnd();
 254     int comeFrom();
 255     Expression *interpret(InterState *istate);
 256     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 257
 258     Statement *inlineScan(InlineScanState *iss);
 259
 260     void toIR(IRState *irs);
 261 };
 262
 263 struct DoStatement : Statement
 264 {
 265     Statement *body;
 266     Expression *condition;
 267
 268     DoStatement(Loc loc, Statement *b, Expression *c);
 269     Statement *syntaxCopy();
 270     Statement *semantic(Scope *sc);
 271     int hasBreak();
 272     int hasContinue();
 273     int usesEH();
 274     int blockExit();
 275     int fallOffEnd();
 276     int comeFrom();
 277     Expression *interpret(InterState *istate);
 278     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 279
 280     Statement *inlineScan(InlineScanState *iss);
 281
 282     void toIR(IRState *irs);
 283 };
 284
 285 struct ForStatement : Statement
 286 {
 287     Statement *init;
 288     Expression *condition;
 289     Expression *increment;
 290     Statement *body;
 291
 292     ForStatement(Loc loc, Statement *init, Expression *condition, Expression *increment, Statement *body);
 293     Statement *syntaxCopy();
 294     Statement *semantic(Scope *sc);
 295     void scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally);
 296     int hasBreak();
 297     int hasContinue();
 298     int usesEH();
 299     int blockExit();
 300     int fallOffEnd();
 301     int comeFrom();
 302     Expression *interpret(InterState *istate);
 303     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 304
 305     Statement *inlineScan(InlineScanState *iss);
 306
 307     void toIR(IRState *irs);
 308 };
 309
 310 struct ForeachStatement : Statement
 311 {
 312     enum TOK op;                // TOKforeach or TOKforeach_reverse
 313     Arguments *arguments;       // array of Argument*'s
 314     Expression *aggr;
 315     Statement *body;
 316
 317     VarDeclaration *key;
 318     VarDeclaration *value;
 319
 320     FuncDeclaration *func;      // function we're lexically in
 321
 322     Array cases;        // put breaks, continues, gotos and returns here
 323     Array gotos;        // forward referenced goto's go here
 324
 325     ForeachStatement(Loc loc, enum TOK op, Arguments *arguments, Expression *aggr, Statement *body);
 326     Statement *syntaxCopy();
 327     Statement *semantic(Scope *sc);
 328     int hasBreak();
 329     int hasContinue();
 330     int usesEH();
 331     int blockExit();
 332     int fallOffEnd();
 333     int comeFrom();
 334     Expression *interpret(InterState *istate);
 335     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 336
 337     Statement *inlineScan(InlineScanState *iss);
 338
 339     void toIR(IRState *irs);
 340 };
 341
 342 struct ForeachRangeStatement : Statement
 343 {
 344     enum TOK op;                // TOKforeach or TOKforeach_reverse
 345     Argument *arg;              // loop index variable
 346     Expression *lwr;
 347     Expression *upr;
 348     Statement *body;
 349
 350     VarDeclaration *key;
 351
 352     ForeachRangeStatement(Loc loc, enum TOK op, Argument *arg,
 353         Expression *lwr, Expression *upr, Statement *body);
 354     Statement *syntaxCopy();
 355     Statement *semantic(Scope *sc);
 356     int hasBreak();
 357     int hasContinue();
 358     int usesEH();
 359     int blockExit();
 360     int fallOffEnd();
 361     int comeFrom();
 362     Expression *interpret(InterState *istate);
 363     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 364
 365     Statement *inlineScan(InlineScanState *iss);
 366
 367     void toIR(IRState *irs);
 368 };
 369
 370 struct IfStatement : Statement
 371 {
 372     Argument *arg;
 373     Expression *condition;
 374     Statement *ifbody;
 375     Statement *elsebody;
 376
 377     VarDeclaration *match;      // for MatchExpression results
 378
 379     IfStatement(Loc loc, Argument *arg, Expression *condition, Statement *ifbody, Statement *elsebody);
 380     Statement *syntaxCopy();
 381     Statement *semantic(Scope *sc);
 382     Expression *interpret(InterState *istate);
 383     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 384     int usesEH();
 385     int blockExit();
 386     int fallOffEnd();
 387     IfStatement *isIfStatement() { return this; }
 388
 389     int inlineCost(InlineCostState *ics);
 390     Expression *doInline(InlineDoState *ids);
 391     Statement *inlineScan(InlineScanState *iss);
 392
 393     void toIR(IRState *irs);
 394 };
 395
 396 struct ConditionalStatement : Statement
 397 {
 398     Condition *condition;
 399     Statement *ifbody;
 400     Statement *elsebody;
 401
 402     ConditionalStatement(Loc loc, Condition *condition, Statement *ifbody, Statement *elsebody);
 403     Statement *syntaxCopy();
 404     Statement *semantic(Scope *sc);
 405     Statements *flatten(Scope *sc);
 406     int usesEH();
 407
 408     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 409 };
 410
 411 struct PragmaStatement : Statement
 412 {
 413     Identifier *ident;
 414     Expressions *args;          // array of Expression's
 415     Statement *body;
 416
 417     PragmaStatement(Loc loc, Identifier *ident, Expressions *args, Statement *body);
 418     Statement *syntaxCopy();
 419     Statement *semantic(Scope *sc);
 420     int usesEH();
 421     int blockExit();
 422     int fallOffEnd();
 423
 424     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 425
 426     void toIR(IRState *irs);
 427 };
 428
 429 struct StaticAssertStatement : Statement
 430 {
 431     StaticAssert *sa;
 432
 433     StaticAssertStatement(StaticAssert *sa);
 434     Statement *syntaxCopy();
 435     Statement *semantic(Scope *sc);
 436
 437     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 438 };
 439
 440 struct SwitchStatement : Statement
 441 {
 442     Expression *condition;
 443     Statement *body;
 444
 445     DefaultStatement *sdefault;
 446     TryFinallyStatement *tf;
 447     Array gotoCases;            // array of unresolved GotoCaseStatement's
 448     Array *cases;               // array of CaseStatement's
 449     int hasNoDefault;           // !=0 if no default statement
 450     int hasVars;                // !=0 if has variable case values
 451
 452     SwitchStatement(Loc loc, Expression *c, Statement *b);
 453     Statement *syntaxCopy();
 454     Statement *semantic(Scope *sc);
 455     int hasBreak();
 456     int usesEH();
 457     int blockExit();
 458     int fallOffEnd();
 459     Expression *interpret(InterState *istate);
 460     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 461
 462     Statement *inlineScan(InlineScanState *iss);
 463
 464     void toIR(IRState *irs);
 465 };
 466
 467 struct CaseStatement : Statement
 468 {
 469     Expression *exp;
 470     Statement *statement;
 471     int index;          // which case it is (since we sort this)
 472     block *cblock;      // back end: label for the block
 473
 474     CaseStatement(Loc loc, Expression *exp, Statement *s);
 475     Statement *syntaxCopy();
 476     Statement *semantic(Scope *sc);
 477     int compare(Object *obj);
 478     int usesEH();
 479     int blockExit();
 480     int fallOffEnd();
 481     int comeFrom();
 482     Expression *interpret(InterState *istate);
 483     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 484
 485     Statement *inlineScan(InlineScanState *iss);
 486
 487     void toIR(IRState *irs);
 488 };
 489
 490 struct DefaultStatement : Statement
 491 {
 492     Statement *statement;
 493 #if IN_GCC
 494     block *cblock;      // back end: label for the block
 495 #endif
 496
 497     DefaultStatement(Loc loc, Statement *s);
 498     Statement *syntaxCopy();
 499     Statement *semantic(Scope *sc);
 500     int usesEH();
 501     int blockExit();
 502     int fallOffEnd();
 503     int comeFrom();
 504     Expression *interpret(InterState *istate);
 505     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 506
 507     Statement *inlineScan(InlineScanState *iss);
 508
 509     void toIR(IRState *irs);
 510 };
 511
 512 struct GotoDefaultStatement : Statement
 513 {
 514     SwitchStatement *sw;
 515
 516     GotoDefaultStatement(Loc loc);
 517     Statement *syntaxCopy();
 518     Statement *semantic(Scope *sc);
 519     Expression *interpret(InterState *istate);
 520     int blockExit();
 521     int fallOffEnd();
 522     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 523
 524     void toIR(IRState *irs);
 525 };
 526
 527 struct GotoCaseStatement : Statement
 528 {
 529     Expression *exp;            // NULL, or which case to goto
 530     CaseStatement *cs;          // case statement it resolves to
 531
 532     GotoCaseStatement(Loc loc, Expression *exp);
 533     Statement *syntaxCopy();
 534     Statement *semantic(Scope *sc);
 535     Expression *interpret(InterState *istate);
 536     int blockExit();
 537     int fallOffEnd();
 538     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 539
 540     void toIR(IRState *irs);
 541 };
 542
 543 struct SwitchErrorStatement : Statement
 544 {
 545     SwitchErrorStatement(Loc loc);
 546     int blockExit();
 547     int fallOffEnd();
 548     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 549
 550     void toIR(IRState *irs);
 551 };
 552
 553 struct ReturnStatement : Statement
 554 {
 555     Expression *exp;
 556
 557     ReturnStatement(Loc loc, Expression *exp);
 558     Statement *syntaxCopy();
 559     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 560     Statement *semantic(Scope *sc);
 561     int blockExit();
 562     int fallOffEnd();
 563     Expression *interpret(InterState *istate);
 564
 565     int inlineCost(InlineCostState *ics);
 566     Expression *doInline(InlineDoState *ids);
 567     Statement *inlineScan(InlineScanState *iss);
 568
 569     void toIR(IRState *irs);
 570
 571     ReturnStatement *isReturnStatement() { return this; }
 572 };
 573
 574 struct BreakStatement : Statement
 575 {
 576     Identifier *ident;
 577
 578     BreakStatement(Loc loc, Identifier *ident);
 579     Statement *syntaxCopy();
 580     Statement *semantic(Scope *sc);
 581     Expression *interpret(InterState *istate);
 582     int blockExit();
 583     int fallOffEnd();
 584     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 585
 586     void toIR(IRState *irs);
 587 };
 588
 589 struct ContinueStatement : Statement
 590 {
 591     Identifier *ident;
 592
 593     ContinueStatement(Loc loc, Identifier *ident);
 594     Statement *syntaxCopy();
 595     Statement *semantic(Scope *sc);
 596     Expression *interpret(InterState *istate);
 597     int blockExit();
 598     int fallOffEnd();
 599     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 600
 601     void toIR(IRState *irs);
 602 };
 603
 604 struct SynchronizedStatement : Statement
 605 {
 606     Expression *exp;
 607     Statement *body;
 608
 609     SynchronizedStatement(Loc loc, Expression *exp, Statement *body);
 610     Statement *syntaxCopy();
 611     Statement *semantic(Scope *sc);
 612     int hasBreak();
 613     int hasContinue();
 614     int usesEH();
 615     int blockExit();
 616     int fallOffEnd();
 617     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 618
 619     Statement *inlineScan(InlineScanState *iss);
 620
 621 // Back end
 622     elem *esync;
 623     SynchronizedStatement(Loc loc, elem *esync, Statement *body);
 624     void toIR(IRState *irs);
 625 };
 626
 627 struct WithStatement : Statement
 628 {
 629     Expression *exp;
 630     Statement *body;
 631     VarDeclaration *wthis;
 632
 633     WithStatement(Loc loc, Expression *exp, Statement *body);
 634     Statement *syntaxCopy();
 635     Statement *semantic(Scope *sc);
 636     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 637     int usesEH();
 638     int blockExit();
 639     int fallOffEnd();
 640
 641     Statement *inlineScan(InlineScanState *iss);
 642
 643     void toIR(IRState *irs);
 644 };
 645
 646 struct TryCatchStatement : Statement
 647 {
 648     Statement *body;
 649     Array *catches;
 650
 651     TryCatchStatement(Loc loc, Statement *body, Array *catches);
 652     Statement *syntaxCopy();
 653     Statement *semantic(Scope *sc);
 654     int hasBreak();
 655     int usesEH();
 656     int blockExit();
 657     int fallOffEnd();
 658
 659     Statement *inlineScan(InlineScanState *iss);
 660
 661     void toIR(IRState *irs);
 662     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 663     TryCatchStatement *isTryCatchStatement() { return this; }
 664 };
 665
 666 struct Catch : Object
 667 {
 668     Loc loc;
 669     Type *type;
 670     Identifier *ident;
 671     VarDeclaration *var;
 672     Statement *handler;
 673
 674     Catch(Loc loc, Type *t, Identifier *id, Statement *handler);
 675     Catch *syntaxCopy();
 676     void semantic(Scope *sc);
 677     int blockExit();
 678     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 679 };
 680
 681 struct TryFinallyStatement : Statement
 682 {
 683     Statement *body;
 684     Statement *finalbody;
 685
 686     TryFinallyStatement(Loc loc, Statement *body, Statement *finalbody);
 687     Statement *syntaxCopy();
 688     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 689     Statement *semantic(Scope *sc);
 690     int hasBreak();
 691     int hasContinue();
 692     int usesEH();
 693     int blockExit();
 694     int fallOffEnd();
 695
 696     Statement *inlineScan(InlineScanState *iss);
 697
 698     void toIR(IRState *irs);
 699 };
 700
 701 struct OnScopeStatement : Statement
 702 {
 703     TOK tok;
 704     Statement *statement;
 705
 706     OnScopeStatement(Loc loc, TOK tok, Statement *statement);
 707     Statement *syntaxCopy();
 708     int blockExit();
 709     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 710     Statement *semantic(Scope *sc);
 711     int usesEH();
 712     void scopeCode(Scope *sc, Statement **sentry, Statement **sexit, Statement **sfinally);
 713
 714     void toIR(IRState *irs);
 715 };
 716
 717 struct ThrowStatement : Statement
 718 {
 719     Expression *exp;
 720
 721     ThrowStatement(Loc loc, Expression *exp);
 722     Statement *syntaxCopy();
 723     Statement *semantic(Scope *sc);
 724     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 725     int blockExit();
 726     int fallOffEnd();
 727
 728     Statement *inlineScan(InlineScanState *iss);
 729
 730     void toIR(IRState *irs);
 731 };
 732
 733 struct VolatileStatement : Statement
 734 {
 735     Statement *statement;
 736
 737     VolatileStatement(Loc loc, Statement *statement);
 738     Statement *syntaxCopy();
 739     Statement *semantic(Scope *sc);
 740     Statements *flatten(Scope *sc);
 741     int blockExit();
 742     int fallOffEnd();
 743     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 744
 745     Statement *inlineScan(InlineScanState *iss);
 746
 747     void toIR(IRState *irs);
 748 };
 749
 750 struct GotoStatement : Statement
 751 {
 752     Identifier *ident;
 753     LabelDsymbol *label;
 754     TryFinallyStatement *tf;
 755
 756     GotoStatement(Loc loc, Identifier *ident);
 757     Statement *syntaxCopy();
 758     Statement *semantic(Scope *sc);
 759     int blockExit();
 760     int fallOffEnd();
 761     Expression *interpret(InterState *istate);
 762
 763     void toIR(IRState *irs);
 764     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 765     GotoStatement *isGotoStatement() { return this; }
 766 };
 767
 768 struct LabelStatement : Statement
 769 {
 770     Identifier *ident;
 771     Statement *statement;
 772     TryFinallyStatement *tf;
 773     block *lblock;              // back end
 774     int isReturnLabel;
 775
 776     LabelStatement(Loc loc, Identifier *ident, Statement *statement);
 777     Statement *syntaxCopy();
 778     Statement *semantic(Scope *sc);
 779     Statements *flatten(Scope *sc);
 780     int usesEH();
 781     int blockExit();
 782     int fallOffEnd();
 783     int comeFrom();
 784     Expression *interpret(InterState *istate);
 785     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 786
 787     Statement *inlineScan(InlineScanState *iss);
 788
 789     void toIR(IRState *irs);
 790 };
 791
 792 struct LabelDsymbol : Dsymbol
 793 {
 794     LabelStatement *statement;
 795 #if IN_GCC
 796     unsigned asmLabelNum;       // GCC-specific
 797 #endif
 798
 799     LabelDsymbol(Identifier *ident);
 800     LabelDsymbol *isLabel();
 801 };
 802
 803 struct AsmStatement : Statement
 804 {
 805     Token *tokens;
 806     code *asmcode;
 807     unsigned asmalign;          // alignment of this statement
 808     unsigned refparam;          // !=0 if function parameter is referenced
 809     unsigned naked;             // !=0 if function is to be naked
 810     unsigned regs;              // mask of registers modified
 811
 812     AsmStatement(Loc loc, Token *tokens);
 813     Statement *syntaxCopy();
 814     Statement *semantic(Scope *sc);
 815     int blockExit();
 816     int comeFrom();
 817
 818     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 819     virtual AsmStatement *isAsmStatement() { return this; }
 820
 821     void toIR(IRState *irs);
 822 };
 823
 824 #ifdef IN_GCC
 825
 826 // Assembler instructions with D expression operands
 827 struct ExtAsmStatement : Statement
 828 {
 829     Expression *insnTemplate;
 830     Expressions *args;
 831     Array *argNames;        // of NULL or Identifier*
 832     Expressions *argConstraints;  // of StringExp*
 833     unsigned nOutputArgs;
 834     Expressions *clobbers;        // of StringExp*
 835
 836     ExtAsmStatement(Loc loc, Expression *insnTemplate, Expressions *args, Array *argNames,
 837         Expressions *argConstraints, int nOutputArgs, Expressions *clobbers);
 838     Statement *syntaxCopy();
 839     Statement *semantic(Scope *sc);
 840     int blockExit();
 841     void toIR(IRState *irs);
 842 };
 843
 844 #endif
 845
 846 #endif /* DMD_STATEMENT_H */