Changeset a16e246


Ignore:
Timestamp:
May 23, 2019, 5:34:16 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:
94b1f718
Parents:
af1e8f56
Message:

Finish Expr printers

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Print.cpp

    raf1e8f56 ra16e246  
    231231                        --indent;
    232232                }
    233                
     233
    234234                if ( node->extension ) {
    235235                        os << std::endl << indent << "... with extension";
     
    659659
    660660        virtual const ast::Expr * visit( const ast::SizeofExpr * node ) {
     661                os << "Sizeof Expression on: ";
     662                ++indent;
     663                if ( node->type ) node->type->accept( *this );
     664                else safe_print( node->expr );
     665                --indent;
     666                postprint( node );
     667
    661668                return node;
    662669        }
    663670
    664671        virtual const ast::Expr * visit( const ast::AlignofExpr * node ) {
     672                os << "Alignof Expression on: ";
     673                ++indent;
     674                if ( node->type ) node->type->accept( *this );
     675                else safe_print( node->expr );
     676                --indent;
     677                postprint( node );
     678               
    665679                return node;
    666680        }
    667681
    668682        virtual const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) {
     683                os << "Untyped Offsetof Expression on member " << node->member << " of ";
     684                ++indent;
     685                safe_print( node->type );
     686                --indent;
     687                postprint( node );
     688
    669689                return node;
    670690        }
    671691
    672692        virtual const ast::Expr * visit( const ast::OffsetofExpr * node ) {
     693                os << "Offsetof Expression on member " << node->member->name << " of ";
     694                ++indent;
     695                safe_print( node->type );
     696                --indent;
     697                postprint( node );
     698
    673699                return node;
    674700        }
    675701
    676702        virtual const ast::Expr * visit( const ast::OffsetPackExpr * node ) {
     703                os << "Offset Pack Expression on: ";
     704                ++indent;
     705                safe_print( node->type );
     706                --indent;
     707                postprint( node );
     708
    677709                return node;
    678710        }
    679711
    680712        virtual const ast::Expr * visit( const ast::LogicalExpr * node ) {
     713                os << "Short-circuited operation (" << (node->isAnd ? "and" : "or") << ") on: ";
     714                safe_print( node->arg1 );
     715                os << " and ";
     716                safe_print( node->arg2 );
     717                postprint( node );
     718
    681719                return node;
    682720        }
    683721
    684722        virtual const ast::Expr * visit( const ast::ConditionalExpr * node ) {
     723                ++indent;
     724                os << "Conditional expression on:" << std::endl << indent;
     725                safe_print( node->arg1 );
     726                os << indent-1 << "First alternative:" << std::endl << indent;
     727                safe_print( node->arg2 );
     728                os << indent-1 << "Second alternative:" << std::endl << indent;
     729                safe_print( node->arg3 );
     730                --indent;
     731                postprint( node );
     732
    685733                return node;
    686734        }
    687735
    688736        virtual const ast::Expr * visit( const ast::CommaExpr * node ) {
     737                ++indent;
     738                os << "Comma Expression:" << std::endl << indent;
     739                safe_print( node->arg1 );
     740                os << std::endl << indent;
     741                safe_print( node->arg2 );
     742                --indent;
     743                postprint( node );
     744
    689745                return node;
    690746        }
    691747
    692748        virtual const ast::Expr * visit( const ast::TypeExpr * node ) {
     749                safe_print( node->type );
     750                postprint( node );
     751
    693752                return node;
    694753        }
    695754
    696755        virtual const ast::Expr * visit( const ast::AsmExpr * node ) {
     756                os << "Asm Expression:" << std::endl;
     757                ++indent;
     758                if ( node->inout ) node->inout->accept( *this );
     759                if ( node->constraint ) node->constraint->accept( *this );
     760                if ( node->operand ) node->operand->accept( *this );
     761                --indent;
     762               
    697763                return node;
    698764        }
    699765
    700766        virtual const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) {
     767                ++indent;
     768                os << "Implicit Copy Constructor Expression:" << std::endl << indent;
     769                safe_print( node->callExpr );
     770                os << std::endl << indent-1 << "... with temporaries:" << std::endl;
     771                printAll( node->tempDecls );
     772                os << std::endl << indent-1 << "... with return temporaries:" << std::endl;
     773                printAll( node->returnDecls );
     774                --indent;
     775                postprint( node );
     776
    701777                return node;
    702778        }
    703779
    704780        virtual const ast::Expr * visit( const ast::ConstructorExpr * node ) {
     781                os <<  "Constructor Expression:" << std::endl << indent+1;
     782                indent += 2;
     783                safe_print( node->callExpr );
     784                indent -= 2;
     785                postprint( node );
     786
    705787                return node;
    706788        }
    707789
    708790        virtual const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) {
     791                ++indent;
     792                os << "Compound Literal Expression: " << std::endl << indent;
     793                safe_print( node->result );
     794                os << indent;
     795                safe_print( node->init );
     796                --indent;
     797                postprint( node );
     798
    709799                return node;
    710800        }
    711801
    712802        virtual const ast::Expr * visit( const ast::RangeExpr * node ) {
     803                os << "Range Expression: ";
     804                safe_print( node->low );
     805                os << " ... ";
     806                safe_print( node->high );
     807                postprint( node );
     808
    713809                return node;
    714810        }
    715811
    716812        virtual const ast::Expr * visit( const ast::UntypedTupleExpr * node ) {
     813                os << "Untyped Tuple:" << std::endl;
     814                ++indent;
     815                printAll( node->exprs );
     816                --indent;
     817                postprint( node );
     818
    717819                return node;
    718820        }
    719821
    720822        virtual const ast::Expr * visit( const ast::TupleExpr * node ) {
     823                os << "Tuple:" << std::endl;
     824                ++indent;
     825                printAll( node->exprs );
     826                --indent;
     827                postprint( node );
     828
    721829                return node;
    722830        }
    723831
    724832        virtual const ast::Expr * visit( const ast::TupleIndexExpr * node ) {
     833                os << "Tuple Index Expression, with tuple:" << std::endl;
     834                ++indent;
     835                os << indent;
     836                safe_print( node->tuple );
     837                os << indent << "with index: " << node->index << std::endl;
     838                --indent;
     839                postprint( node );
     840               
    725841                return node;
    726842        }
    727843
    728844        virtual const ast::Expr * visit( const ast::TupleAssignExpr * node ) {
     845                os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
     846                ++indent;
     847                os << indent;
     848                safe_print( node->stmtExpr );
     849                --indent;
     850                postprint( node );
     851
    729852                return node;
    730853        }
    731854
    732855        virtual const ast::Expr * visit( const ast::StmtExpr * node ) {
     856                ++indent;
     857                os << "Statement Expression:" << std::endl << indent;
     858                safe_print( node->stmts );
     859                if ( ! node->returnDecls.empty() ) {
     860                        os << indent << "... with returnDecls: ";
     861                        printAll( node->returnDecls );
     862                }
     863                if ( ! node->dtors.empty() ) {
     864                        os << indent << "... with dtors: ";
     865                        printAll( node->dtors );
     866                }
     867                --indent;
     868                postprint( node );
     869
    733870                return node;
    734871        }
    735872
    736873        virtual const ast::Expr * visit( const ast::UniqueExpr * node ) {
     874                ++indent;
     875                os << "Unique Expression with id: " << node->id << std::endl << indent;
     876                safe_print( node->expr );
     877                if ( node->object ) {
     878                        os << indent-1 << "... with decl: ";
     879                        short_print( node->object );
     880                }
     881                --indent;
     882                postprint( node );
     883
    737884                return node;
    738885        }
    739886
    740887        virtual const ast::Expr * visit( const ast::UntypedInitExpr * node ) {
     888                ++indent;
     889                os << "Untyped Init Expression" << std::endl << indent;
     890                safe_print( node->expr );
     891                if ( ! node->initAlts.empty() ) {
     892                        for ( const InitAlternative & alt : node->initAlts ) {
     893                                os << indent <<  "InitAlternative: ";
     894                                safe_print( alt.type );
     895                                safe_print( alt.designation );
     896                        }
     897                }
     898                --indent;
     899
    741900                return node;
    742901        }
    743902
    744903        virtual const ast::Expr * visit( const ast::InitExpr * node ) {
     904                ++indent;
     905                os << "Init Expression" << std::endl << indent;
     906                safe_print( node->expr );
     907                os << indent << "... with designation: ";
     908                safe_print( node->designation );
     909                --indent;
     910
    745911                return node;
    746912        }
    747913
    748914        virtual const ast::Expr * visit( const ast::DeletedExpr * node ) {
     915                ++indent;
     916                os << "Deleted Expression" << std::endl << indent;
     917                safe_print( node->expr );
     918                os << std::endl << indent << "... deleted by: ";
     919                safe_print( node->deleteStmt );
     920                --indent;
     921
    749922                return node;
    750923        }
    751924
    752925        virtual const ast::Expr * visit( const ast::DefaultArgExpr * node ) {
     926                ++indent;
     927                os << "Default Argument Expression" << std::endl << indent;
     928                safe_print( node->expr );
     929                --indent;
     930
    753931                return node;
    754932        }
    755933
    756934        virtual const ast::Expr * visit( const ast::GenericExpr * node ) {
     935                ++indent;
     936                os << "C11 _Generic Expression" << std::endl << indent;
     937                safe_print( node->control );
     938                os << std::endl << indent << "... with associations:" << std::endl;
     939                for ( const auto & assoc : node->associations ) {
     940                        os << indent;
     941                        if ( assoc.type ) {
     942                                os << "... type: ";
     943                                assoc.type->accept( *this );
     944                                os << std::endl << indent << "... expression: ";
     945                                safe_print( assoc.expr );
     946                        } else {
     947                                os << "... default: ";
     948                                safe_print( assoc.expr );
     949                        }
     950                        os << std::endl;
     951                }
     952                --indent;
     953
    757954                return node;
    758955        }
Note: See TracChangeset for help on using the changeset viewer.