Changeset 6f4b7f2


Ignore:
Timestamp:
May 24, 2019, 5:26:44 PM (2 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, cleanup-dtors, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
a7d50b6, c519942
Parents:
21a44ca
Message:

Finish Stmt printers, implement short_mode for Decls

Location:
src/AST
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    r21a44ca r6f4b7f2  
    397397                ThrowStmt::Kind kind;
    398398                switch (node->kind) {
    399                 case ast::ThrowStmt::Terminate:
     399                case ast::ExceptionKind::Terminate:
    400400                        kind = ThrowStmt::Terminate;
    401401                        break;
    402                 case ast::ThrowStmt::Resume:
     402                case ast::ExceptionKind::Resume:
    403403                        kind = ThrowStmt::Resume;
    404404                        break;
     
    429429                CatchStmt::Kind kind;
    430430                switch (node->kind) {
    431                 case ast::CatchStmt::Terminate:
     431                case ast::ExceptionKind::Terminate:
    432432                        kind = CatchStmt::Terminate;
    433433                        break;
    434                 case ast::CatchStmt::Resume:
     434                case ast::ExceptionKind::Resume:
    435435                        kind = CatchStmt::Resume;
    436436                        break;
     
    17391739        virtual void visit( ThrowStmt * old ) override final {
    17401740                if ( inCache( old ) ) return;
    1741                 ast::ThrowStmt::Kind kind;
     1741                ast::ExceptionKind kind;
    17421742                switch (old->kind) {
    17431743                case ThrowStmt::Terminate:
    1744                         kind = ast::ThrowStmt::Terminate;
     1744                        kind = ast::ExceptionKind::Terminate;
    17451745                        break;
    17461746                case ThrowStmt::Resume:
    1747                         kind = ast::ThrowStmt::Resume;
     1747                        kind = ast::ExceptionKind::Resume;
    17481748                        break;
    17491749                default:
     
    17751775        virtual void visit( CatchStmt * old ) override final {
    17761776                if ( inCache( old ) ) return;
    1777                 ast::CatchStmt::Kind kind;
     1777                ast::ExceptionKind kind;
    17781778                switch (old->kind) {
    17791779                case CatchStmt::Terminate:
    1780                         kind = ast::CatchStmt::Terminate;
     1780                        kind = ast::ExceptionKind::Terminate;
    17811781                        break;
    17821782                case CatchStmt::Resume:
    1783                         kind = ast::CatchStmt::Resume;
     1783                        kind = ast::ExceptionKind::Resume;
    17841784                        break;
    17851785                default:
  • src/AST/Print.cpp

    r21a44ca r6f4b7f2  
    7171
    7272        /// call to print short form. Incorporates features of safe_print()
    73         void short_print( const ast::Node * n ) {
     73        void short_print( const ast::Decl * n ) {
    7474                if ( ! n ) { undefined(); return; }
    7575                bool old_short = short_mode; short_mode = true;
     
    7777                short_mode = old_short;
    7878        }
    79 
    8079
    8180        static const char* Names[];
     
    178177
    179178        void print( const ast::AggregateDecl * node ) {
    180                 os << node->typeString() << " " << node->name << ":";
    181                 if ( node->linkage != Linkage::Cforall ) {
     179                os << node->typeString() << " " << node->name;
     180               
     181                if ( ! short_mode && node->linkage != Linkage::Cforall ) {
    182182                        os << " " << Linkage::name( node->linkage );
    183                 } // if
    184                 os << " with body : " << (node->body ? "yes " : "no ");
     183                }
     184               
     185                os << " " << (node->body ? "with" : "without") << " body";
    185186
    186187                if ( ! node->params.empty() ) {
     
    189190                        printAll( node->params );
    190191                        --indent;
    191                 } // if
    192                 if ( ! node->members.empty() ) {
     192                }
     193
     194                if ( ! short_mode && ! node->members.empty() ) {
    193195                        os << endl << indent << "... with members" << endl;
    194196                        ++indent;
    195197                        printAll( node->members );
    196198                        --indent;
    197                 } // if
    198                 if ( ! node->attributes.empty() ) {
     199                }
     200
     201                if ( ! short_mode && ! node->attributes.empty() ) {
    199202                        os << endl << indent << "... with attributes" << endl;
    200203                        ++indent;
    201204                        printAll( node->attributes );
    202205                        --indent;
    203                 } // if
     206                }
     207
    204208                os << endl;
    205209        }
    206210
    207         void print( const ast::NamedTypeDecl * node ) {
    208                 if ( !node->name.empty() ) os << node->name << ": ";
    209 
    210                 if ( node->linkage != Linkage::Cforall ) {
     211        void preprint( const ast::NamedTypeDecl * node ) {
     212                if ( ! node->name.empty() ) os << node->name << ": ";
     213
     214                if ( ! short_mode && node->linkage != Linkage::Cforall ) {
    211215                        os << Linkage::name( node->linkage ) << " ";
    212                 } // if
     216                }
     217
    213218                print( node->storage );
    214219                os << node->typeString();
     220               
    215221                if ( node->base ) {
    216222                        os << " for ";
     
    218224                        node->base->accept( *this );
    219225                        --indent;
    220                 } // if
     226                }
     227
    221228                if ( ! node->params.empty() ) {
    222229                        os << endl << indent << "... with parameters" << endl;
     
    224231                        printAll( node->params );
    225232                        --indent;
    226                 } // if
    227                 if ( ! node->assertions.empty() ) {
     233                }
     234
     235                if ( ! short_mode && ! node->assertions.empty() ) {
    228236                        os << endl << indent << "... with assertions" << endl;
    229237                        ++indent;
    230238                        printAll( node->assertions );
    231239                        --indent;
    232                 } // if
     240                }
    233241        }
    234242
     
    265273public:
    266274        virtual const ast::DeclWithType * visit( const ast::ObjectDecl * node ) {
    267                 if ( !node->name.empty() ) os << node->name << ": ";
    268 
    269                 if ( node->linkage != Linkage::Cforall ) {
     275                if ( ! node->name.empty() ) os << node->name << ": ";
     276
     277                if ( ! short_mode && node->linkage != Linkage::Cforall ) {
    270278                        os << Linkage::name( node->linkage ) << " ";
    271                 } // if
     279                }
    272280
    273281                print( node->storage );
     
    277285                } else {
    278286                        os << "untyped entity";
    279                 } // if
    280 
    281                 if ( node->init ) {
     287                }
     288
     289                if ( ! short_mode && node->init ) {
     290                        ++indent;
    282291                        os << " with initializer (" << (
    283292                                node->init->maybeConstructed
    284293                                        ? "maybe constructed"
    285294                                        : "not constructed"
    286                                 ) << ")" << endl << indent+1;
    287 
    288                         ++indent;
     295                                ) << ")" << endl << indent;
    289296                        node->init->accept( *this );
    290297                        --indent;
    291298                        os << endl;
    292                 } // if
    293 
    294                 if ( ! node->attributes.empty() ) {
     299                }
     300
     301                if ( ! short_mode && ! node->attributes.empty() ) {
    295302                        os << endl << indent << "... with attributes:" << endl;
    296303                        ++indent;
     
    302309                        os << indent << " with bitfield width ";
    303310                        node->bitfieldWidth->accept( *this );
    304                 } // if
     311                }
     312
    305313                return node;
    306314        }
    307315
    308316        virtual const ast::DeclWithType * visit( const ast::FunctionDecl * node ) {
    309                 if ( !node->name.empty() ) {
    310                         os << node->name << ": ";
    311                 } // if
    312                 if ( node->linkage != Linkage::Cforall ) {
     317                if ( !node->name.empty() ) os << node->name << ": ";
     318
     319                if ( ! short_mode && node->linkage != Linkage::Cforall ) {
    313320                        os << Linkage::name( node->linkage ) << " ";
    314                 } // if
    315 
    316                 printAll( node->attributes );
     321                }
     322
     323                if ( ! short_mode ) printAll( node->attributes );
    317324
    318325                print( node->storage );
     
    323330                } else {
    324331                        os << "untyped entity";
    325                 } // if
    326 
    327                 if ( node->stmts ) {
    328                         os << indent << "... with body" << endl << indent+1;
    329                         ++indent;
     332                }
     333
     334                if ( ! short_mode && node->stmts ) {
     335                        ++indent;
     336                        os << " with body" << endl << indent;
    330337                        node->stmts->accept( *this );
    331338                        --indent;
    332                 } // if
     339                }
     340
    333341                return node;
    334342        }
     
    355363
    356364        virtual const ast::Decl * visit( const ast::TypeDecl * node ) {
    357                 print( node );
    358                 if ( node->init ) {
     365                preprint( node );
     366                if ( ! short_mode && node->init ) {
    359367                        os << endl << indent << "with type initializer: ";
    360368                        ++indent;
     
    362370                        --indent;
    363371                }
     372
    364373                return node;
    365374        }
    366375
    367376        virtual const ast::Decl * visit( const ast::TypedefDecl * node ) {
    368                 print( node );
     377                preprint( node );
    369378                return node;
    370379        }
    371380
    372381        virtual const ast::AsmDecl * visit( const ast::AsmDecl * node ) {
    373                 node->stmt->accept( *this );
     382                safe_print( node->stmt );
    374383                return node;
    375384        }
     
    378387                os << "Static Assert with condition: ";
    379388                ++indent;
    380                 node->cond->accept( *this );
    381                 --indent;
    382                 os << endl << indent << "and message: ";
    383                 ++indent;
    384                 node->msg->accept( *this );
     389                safe_print( node->cond );
     390                os << endl << indent-1 << "and message: ";
     391                safe_print( node->msg );
    385392                --indent;
    386393                os << endl;
     394
    387395                return node;
    388396        }
     
    594602
    595603        virtual const ast::Stmt * visit( const ast::ThrowStmt * node ) {
     604                if ( node->target ) os << "Non-Local ";
     605
     606                switch( node->kind ) {
     607                case ast::ExceptionKind::Terminate: os << "Terminate "; break;
     608                case ast::ExceptionKind::Resume:    os << "Resume ";    break;
     609                }
     610
     611                ++indent;
     612                os << "Throw Statement, raising: ";
     613                safe_print( node->expr );
     614                if ( node->target ) {
     615                        os << "... at: ";
     616                        node->target->accept( *this );
     617                }
     618                --indent;
     619
    596620                return node;
    597621        }
    598622
    599623        virtual const ast::Stmt * visit( const ast::TryStmt * node ) {
     624                ++indent;
     625                os << "Try Statement" << endl << indent-1
     626                   << "... with block:" << endl << indent;
     627                safe_print( node->body );
     628
     629                os << indent-1 << "... and handlers:" << endl;
     630                for ( const ast::CatchStmt * stmt : node->handlers ) {
     631                        os << indent;
     632                        stmt->accept( *this );
     633                }
     634
     635                if ( node->finally ) {
     636                        os << indent-1 << "... and finally:" << endl << indent;
     637                        node->finally->accept( *this );
     638                }
     639                --indent;
     640
    600641                return node;
    601642        }
    602643
    603644        virtual const ast::Stmt * visit( const ast::CatchStmt * node ) {
     645                os << "Catch ";
     646                switch ( node->kind ) {
     647                case ast::ExceptionKind::Terminate: os << "Terminate "; break;
     648                case ast::ExceptionKind::Resume:    os << "Resume ";    break;
     649                }
     650                os << "Statement" << endl << indent;
     651
     652                ++indent;
     653                os << "... catching: ";
     654                short_print( node->decl );
     655                os << endl;
     656
     657                if ( node->cond ) {
     658                        os << indent-1 << "... with conditional:" << endl << indent;
     659                        node->cond->accept( *this );
     660                }
     661
     662                os << indent-1 << "... with block:" << endl << indent;
     663                safe_print( node->body );
     664                --indent;
     665               
    604666                return node;
    605667        }
    606668
    607669        virtual const ast::Stmt * visit( const ast::FinallyStmt * node ) {
     670                os << "Finally Statement" << endl;
     671                os << indent << "... with block:" << endl;
     672                ++indent;
     673                os << indent;
     674                safe_print( node->body );
     675                --indent;
     676
    608677                return node;
    609678        }
    610679
    611680        virtual const ast::Stmt * visit( const ast::WaitForStmt * node ) {
     681                os << "Waitfor Statement" << endl;
     682                indent += 2;
     683                for( const auto & clause : node->clauses ) {
     684                        os << indent-1 << "target function: ";
     685                        safe_print( clause.target.func );
     686                       
     687                        if ( ! clause.target.args.empty() ) {
     688                                os << endl << indent-1 << "... with arguments:" << endl;
     689                                for( const ast::Expr * arg : clause.target.args ) {
     690                                        arg->accept( *this );
     691                                }
     692                        }
     693
     694                        if ( clause.stmt ) {
     695                                os << indent-1 << "... with statment:" << endl;
     696                                clause.stmt->accept( *this );
     697                        }
     698
     699                        if ( clause.cond ) {
     700                                os << indent-1 << "... with condition:" << endl;
     701                                clause.cond->accept( *this );
     702                        }
     703                }
     704
     705                if ( node->timeout.time ) {
     706                        os << indent-1 << "timeout of:" << endl;
     707                        node->timeout.time->accept( *this );
     708
     709                        if ( node->timeout.stmt ) {
     710                                os << indent-1 << "... with statment:" << endl;
     711                                node->timeout.stmt->accept( *this );
     712                        }
     713
     714                        if ( node->timeout.cond ) {
     715                                os << indent-1 << "... with condition:" << endl;
     716                                node->timeout.cond->accept( *this );
     717                        }
     718                }
     719
     720                if ( node->orElse.stmt ) {
     721                        os << indent-1 << "else:" << endl;
     722                        node->orElse.stmt->accept( *this );
     723
     724                        if ( node->orElse.cond ) {
     725                                os << indent-1 << "... with condition:" << endl;
     726                                node->orElse.cond->accept( *this );
     727                        }
     728                }
     729                indent -= 2;
     730
    612731                return node;
    613732        }
    614733
    615734        virtual const ast::Stmt * visit( const ast::WithStmt * node ) {
     735                os << "With statement" << endl;
     736                os << indent << "... with expressions:" << endl;
     737                ++indent;
     738                printAll( node->exprs );
     739                os << indent-1 << "... with statement:" << endl << indent;
     740                safe_print( node->stmt );
     741                --indent;
     742
    616743                return node;
    617744        }
     
    625752
    626753        virtual const ast::Stmt * visit( const ast::DeclStmt * node ) {
     754                os << "Declaration of ";
     755                safe_print( node->decl );
     756
    627757                return node;
    628758        }
    629759
    630760        virtual const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) {
     761                os << "Implicit Ctor Dtor Statement" << endl;
     762                os << indent << "... with Ctor/Dtor: ";
     763                ++indent;
     764                safe_print( node->callStmt );
     765                --indent;
     766                os << endl;
     767
    631768                return node;
    632769        }
     
    13751512}
    13761513
    1377 void printShort( ostream & os, const ast::Node * node, Indenter indent ) {
     1514void printShort( ostream & os, const ast::Decl * node, Indenter indent ) {
    13781515        Printer printer { os, indent, true };
    13791516        node->accept(printer);
  • src/AST/Print.hpp

    r21a44ca r6f4b7f2  
    2323namespace ast {
    2424
     25class Decl;
     26
     27/// Print a node with the given indenter
    2528void print( std::ostream & os, const ast::Node * node, Indenter indent = {} );
    2629
     
    2932}
    3033
     34/// Print a declaration in its short form
     35void printShort( std::ostream & os, const ast::Decl * node, Indenter indent = {} );
     36
     37inline void printShort( std::ostream & os, const ast::Decl * node, unsigned int indent ) {
     38    printShort( os, node, Indenter{ Indenter::tabsize, indent } );
    3139}
     40
     41}
  • src/AST/Stmt.hpp

    r21a44ca r6f4b7f2  
    268268};
    269269
     270/// Kind of exception
     271enum ExceptionKind { Terminate, Resume };
     272
    270273/// Throw statement `throw ...`
    271274class ThrowStmt final : public Stmt {
    272275public:
    273         enum Kind { Terminate, Resume };
    274 
    275276        ptr<Expr> expr;
    276277        ptr<Expr> target;
    277         Kind kind;
    278 
    279         ThrowStmt( const CodeLocation & loc, Kind kind, const Expr * expr, const Expr * target,
     278        ExceptionKind kind;
     279
     280        ThrowStmt(
     281                const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
    280282                std::vector<Label> && labels = {} )
    281283        : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
     
    294296        ptr<FinallyStmt> finally;
    295297
    296         TryStmt( const CodeLocation & loc, const CompoundStmt * body,
     298        TryStmt(
     299                const CodeLocation & loc, const CompoundStmt * body,
    297300                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
    298301                std::vector<Label> && labels = {} )
     
    308311class CatchStmt final : public Stmt {
    309312public:
    310         enum Kind { Terminate, Resume };
    311 
    312313        ptr<Decl> decl;
    313314        ptr<Expr> cond;
    314315        ptr<Stmt> body;
    315         Kind kind;
    316 
    317         CatchStmt( const CodeLocation & loc, Kind kind, const Decl * decl, const Expr * cond,
     316        ExceptionKind kind;
     317
     318        CatchStmt(
     319                const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
    318320                const Stmt * body, std::vector<Label> && labels = {} )
    319321        : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
  • src/AST/porting.md

    r21a44ca r6f4b7f2  
    3737  * all subclass constructors must fill it; by convention, from their first argument
    3838
    39 `N->print(std::ostream&)` is a visitor now, port these methods to `ast::Print` class
    40 * **TODO** `Declaration::printShort` should also be integrated
     39`N->print(std::ostream&)` is a visitor now
     40* `Declaration::printShort` is also integrated
    4141
    4242`clone` is private to `Node` now
     
    137137* `parameters` => `params`
    138138
    139 `EnumDecl`
    140 * **TODO** rebuild `eval` for new AST (re: `valueOf` implementation)
    141 
    142139`Expr`
    143140* Merged `inferParams`/`resnSlots` into union, as suggested by comment in old version
     
    151148* `function` => `func`
    152149* removed `begin_args()` in favour of `args.begin()`
    153 
    154 `MemberExpr`
    155 * **TODO** port setup of `result` in constructor
    156150
    157151`ConstantExpr`
     
    204198`TryStmt`
    205199* `block` -> `body` and `finallyBlock` -> `finally`
     200
     201`ThrowStmt` `CatchStmt`
     202* moved `Kind` enums to shared `ast::ExceptionKind` enum
    206203
    207204`FinallyStmt`
Note: See TracChangeset for help on using the changeset viewer.