Changes in / [21a44ca:f1ec88a]


Ignore:
Location:
src/AST
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Label.hpp

    r21a44ca rf1ec88a  
    3939
    4040        operator std::string () const { return name; }
    41         bool empty() const { return name.empty(); }
     41        bool empty() { return name.empty(); }
    4242};
    4343

  • src/AST/Print.cpp

    r21a44ca rf1ec88a  
    118118        }
    119119
    120         void print( const std::vector<ast::Label> & labels ) {
    121                 if ( labels.empty() ) return;
    122                 os << indent << "... Labels: {";
    123                 bool isFirst = true;
    124                 for ( const Label & l : labels ) {
    125                         if ( isFirst ) { isFirst = false; } else { os << ","; }
    126                         os << l;
    127                 }
    128                 os << "}" << endl;
    129         }
    130 
    131120        void print( const ast::Expr::InferUnion & inferred, unsigned level = 0 ) {
    132121                switch ( inferred.mode ) {
    133122                case ast::Expr::InferUnion::Empty: return;
    134123                case ast::Expr::InferUnion::Slots: {
    135                         os << indent << "with " << inferred.data.resnSlots.size()
    136                            << " pending inference slots" << endl;
     124                        os << indent << "with " << inferred.data.resnSlots.size() << " pending inference slots"
     125                           << std::endl;
    137126                        return;
    138127                }
    139128                case ast::Expr::InferUnion::Params: {
    140                         os << indent << "with inferred parameters " << level << ":" << endl;
     129                        os << indent << "with inferred parameters " << level << ":" << std::endl;
    141130                        ++indent;
    142131                        for ( const auto & i : inferred.data.inferParams ) {
    143132                                os << indent;
    144133                                short_print( Decl::fromId( i.second.decl ) );
    145                                 os << endl;
     134                                os << std::endl;
    146135                                print( i.second.expr->inferred, level+1 );
    147136                        }
    … …  
    154143        void print( const ast::ParameterizedType::ForallList & forall ) {
    155144                if ( forall.empty() ) return;   
    156                 os << "forall" << endl;
     145                os << "forall" << std::endl;
    157146                ++indent;
    158147                printAll( forall );
    … …  
    163152        void print( const std::vector<ptr<Attribute>> & attrs ) {
    164153                if ( attrs.empty() ) return;
    165                 os << "with attributes" << endl;
     154                os << "with attributes" << std::endl;
    166155                ++indent;
    167156                printAll( attrs );
    … …  
    171160        void print( const std::vector<ptr<Expr>> & params ) {
    172161                if ( params.empty() ) return;
    173                 os << endl << indent << "... with parameters" << endl;
     162                os << std::endl << indent << "... with parameters" << std::endl;
    174163                ++indent;
    175164                printAll( params );
    … …  
    237226
    238227                if ( node->env ) {
    239                         os << endl << indent << "... with environment:" << endl;
     228                        os << std::endl << indent << "... with environment:" << std::endl;
    240229                        ++indent;
    241230                        node->env->accept( *this );
    242231                        --indent;
    243232                }
    244 
     233               
    245234                if ( node->extension ) {
    246                         os << endl << indent << "... with extension";
     235                        os << std::endl << indent << "... with extension";
    247236                }
    248237        }
    … …  
    389378
    390379        virtual const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) {
    391                 os << "Compound Statement:" << endl;
     380                os << "CompoundStmt" << endl;
    392381                ++indent;
    393382                printAll( node->kids );
    … …  
    407396                os << "Assembler Statement:" << endl;
    408397                ++indent;
    409                 os << indent-1 << "instruction:" << endl << indent;
    410                 safe_print( node->instruction );
     398                os << indent << "instruction: " << endl << indent;
     399                node->instruction->accept( *this );
    411400                if ( ! node->output.empty() ) {
    412                         os << endl << indent << "output:" << endl;
     401                        os << endl << indent+1 << "output: " << endl;
    413402                        printAll( node->output );
    414403                } // if
    415404                if ( ! node->input.empty() ) {
    416                         os << indent << "input:" << endl;
     405                        os << indent+1 << "input: " << endl;
    417406                        printAll( node->input );
    418407                } // if
    419408                if ( ! node->clobber.empty() ) {
    420                         os << indent << "clobber:" << endl;
     409                        os << indent+1 << "clobber: " << endl;
    421410                        printAll( node->clobber );
    422411                } // if
    … …  
    426415
    427416        virtual const ast::Stmt * visit( const ast::DirectiveStmt * node ) {
    428                 os << "GCC Directive: " << node->directive << endl;
     417                os << "GCC Directive:" << node->directive << endl;
    429418                return node;
    430419        }
    431420
    432421        virtual const ast::Stmt * visit( const ast::IfStmt * node ) {
    433                 os << "If on condition:" << endl;
    434                 ++indent;
    435                 os << indent;
     422                os << "If on condition: " << endl;
     423                os << indent+1;
     424                ++indent;
    436425                safe_print( node->cond );
    437426                --indent;
    438427
    439                 if ( ! node->inits.empty() ) {
    440                         os << indent << "... with initialization:" << endl;
    441                         ++indent;
    442                         for ( const ast::Stmt * stmt : node->inits ) {
     428                if ( !node->inits.empty() ) {
     429                        os << indent << "... with initialization: \n";
     430                        ++indent;
     431                        for ( const Stmt * stmt : node->inits ) {
    443432                                os << indent;
    444                                 safe_print( stmt );
     433                                stmt->accept( *this );
    445434                        }
    446435                        --indent;
    … …  
    448437                }
    449438
    450                 os << indent << "... then:" << endl;
     439                os << indent << "... then: " << endl;
    451440
    452441                ++indent;
    … …  
    456445
    457446                if ( node->elsePart != 0 ) {
    458                         os << indent << "... else:" << endl;
     447                        os << indent << "... else: " << endl;
    459448                        ++indent;
    460449                        os << indent;
    … …  
    466455
    467456        virtual const ast::Stmt * visit( const ast::WhileStmt * node ) {
    468                 if ( node->isDoWhile ) { os << "Do-"; }
    469                 os << "While on condition:" << endl;
    470                 ++indent;
    471                 safe_print( node->cond );
    472                 os << indent-1 << "... with body:" << endl;
    473                 safe_print( node->body );
    474 
    475                 if ( ! node->inits.empty() ) {
    476                         os << indent-1 << "... with inits:" << endl;
    477                         printAll( node->inits );
    478                 }
    479                 --indent;
    480 
    481457                return node;
    482458        }
    483459
    484460        virtual const ast::Stmt * visit( const ast::ForStmt * node ) {
    485                 os << "For Statement" << endl;
    486 
    487                 if ( ! node->inits.empty() ) {
    488                         os << indent << "... initialization:" << endl;
    489                         ++indent;
    490                         for ( const ast::Stmt * stmt : node->inits ) {
    491                                 os << indent+1;
    492                                 safe_print( stmt );
    493                         }
    494                         --indent;
    495                 }
    496 
    497                 if ( node->cond ) {
    498                         os << indent << "... condition:" << endl;
    499                         ++indent;
    500                         os << indent;
    501                         node->cond->accept( *this );
    502                         --indent;
    503                 }
    504 
    505                 if ( node->inc ) {
    506                         os << indent << "... increment:" << endl;
    507                         ++indent;
    508                         os << indent;
    509                         node->inc->accept( *this );
    510                         --indent;
    511                 }
    512 
    513                 if ( node->body ) {
    514                         os << indent << "... with body:" << endl;
    515                         ++indent;
    516                         os << indent;
    517                         node->body->accept( *this );
    518                         --indent;
    519                 }
    520                 os << endl;
    521                 print( node->labels );
    522 
    523461                return node;
    524462        }
    525463
    526464        virtual const ast::Stmt * visit( const ast::SwitchStmt * node ) {
    527                 os << "Switch on condition: ";
    528                 safe_print( node->cond );
    529                 os << endl;
    530 
    531                 ++indent;
    532                 for ( const ast::Stmt * stmt : node->stmts ) {
    533                         stmt->accept( *this );
    534                 }
    535                 --indent;
    536 
    537465                return node;
    538466        }
    539467
    540468        virtual const ast::Stmt * visit( const ast::CaseStmt * node ) {
    541                 if ( node->isDefault() ) {
    542                         os << indent << "Default ";
    543                 } else {
    544                         os << indent << "Case ";
    545                         safe_print( node->cond );
    546                 } // if
    547                 os << endl;
    548 
    549                 ++indent;
    550                 for ( const ast::Stmt * stmt : node->stmts ) {
    551                         os << indent;
    552                         stmt->accept( *this );
    553                 }
    554                 --indent;
    555 
    556469                return node;
    557470        }
    558471
    559472        virtual const ast::Stmt * visit( const ast::BranchStmt * node ) {
    560                 os << "Branch (" << node->kindName() << ")" << endl;
    561                 ++indent;
    562                 if ( ! node->target.empty() ) {
    563                         os << indent << "with target: " << node->target << endl;
    564                 }
    565 
    566                 if ( ! node->originalTarget.empty() ) {
    567                         os << indent << "with original target: " << node->originalTarget << endl;
    568                 }
    569 
    570                 if ( node->computedTarget ) {
    571                         os << indent << "with computed target: ";
    572                         node->computedTarget->accept( *this );
    573                         os << endl;
    574                 }
    575                 --indent;
    576 
    577473                return node;
    578474        }
    579475
    580476        virtual const ast::Stmt * visit( const ast::ReturnStmt * node ) {
    581                 os << "Return Statement, returning";
    582                 if ( node->expr ) {
    583                         ++indent;
    584                         os << ":" << endl << indent;
    585                         node->expr->accept( *this );
    586                         --indent;
    587                 } else {
    588                         os << " void";
    589                 }
    590                 os << endl;
    591 
    592477                return node;
    593478        }
    … …  
    618503
    619504        virtual const ast::NullStmt * visit( const ast::NullStmt * node ) {
    620                 os << "Null Statement" << endl;
    621                 print( node->labels );
    622 
    623505                return node;
    624506        }
    … …  
    634516        virtual const ast::Expr * visit( const ast::ApplicationExpr * node ) {
    635517                ++indent;
    636                 os << "Application of" << endl << indent;
     518                os << "Application of" << std::endl << indent;
    637519                safe_print( node->func );
    638                 os << endl;
     520                os << std::endl;
    639521                if ( ! node->args.empty() ) {
    640                         os << indent << "... to arguments" << endl;
     522                        os << indent << "... to arguments" << std::endl;
    641523                        printAll( node->args );
    642524                }
    … …  
    649531        virtual const ast::Expr * visit( const ast::UntypedExpr * node ) {
    650532                ++indent;
    651                 os << "Applying untyped:" << endl;
     533                os << "Applying untyped:" << std::endl;
    652534                os << indent;
    653535                safe_print( node->func );
    654                 os << endl << indent-1 << "...to:" << endl;
     536                os << std::endl << indent-1 << "...to:" << std::endl;
    655537                printAll( node->args );
    656538                --indent;
    … …  
    668550
    669551        virtual const ast::Expr * visit( const ast::AddressExpr * node ) {
    670                 os << "Address of:" << endl;
     552                os << "Address of:" << std::endl;
    671553                ++indent;
    672554                os << indent;
    … …  
    686568        virtual const ast::Expr * visit( const ast::CastExpr * node ) {
    687569                ++indent;
    688                 os << (node->isGenerated ? "Generated" : "Explicit") << " cast of:" << endl << indent;
     570                os << (node->isGenerated ? "Generated" : "Explicit") << " cast of:" << std::endl << indent;
    689571                safe_print( node->arg );
    690                 os << endl << indent-1 << "... to:";
     572                os << std::endl << indent-1 << "... to:";
    691573                if ( ! node->result ) {
    692574                        os << " ";
    … …  
    695577                        os << " nothing";
    696578                } else {
    697                         os << endl << indent;
     579                        os << std::endl << indent;
    698580                        node->result->accept( *this );
    699581                } // if
    … …  
    706588        virtual const ast::Expr * visit( const ast::KeywordCastExpr * node ) {
    707589                ++indent;
    708                 os << "Keyword Cast of:" << endl << indent;
     590                os << "Keyword Cast of:" << std::endl << indent;
    709591                safe_print( node->arg );
    710592                --indent;
    711                 os << endl << indent << "... to: " << node->targetString();
     593                os << std::endl << indent << "... to: " << node->targetString();
    712594                postprint( node );
    713595
    … …  
    717599        virtual const ast::Expr * visit( const ast::VirtualCastExpr * node ) {
    718600                ++indent;
    719                 os << "Virtual Cast of:" << endl << indent;
     601                os << "Virtual Cast of:" << std::endl << indent;
    720602                safe_print( node->arg );
    721                 os << endl << indent-1 << "... to:";
     603                os << std::endl << indent-1 << "... to:";
    722604                if ( ! node->result ) {
    723605                        os << " unknown";
    724606                } else {
    725                         os << endl << indent;
     607                        os << std::endl << indent;
    726608                        node->result->accept( *this );
    727609                }
    … …  
    734616        virtual const ast::Expr * visit( const ast::UntypedMemberExpr * node ) {
    735617                ++indent;
    736                 os << "Untyped Member Expression, with field: " << endl << indent;
     618                os << "Untyped Member Expression, with field: " << std::endl << indent;
    737619                safe_print( node->member );
    738                 os << indent-1 << "... from aggregate:" << endl << indent;
     620                os << indent-1 << "... from aggregate:" << std::endl << indent;
    739621                safe_print( node->aggregate );
    740622                --indent;
    … …  
    746628        virtual const ast::Expr * visit( const ast::MemberExpr * node ) {
    747629                ++indent;
    748                 os << "Member Expression, with field:" << endl << indent;
     630                os << "Member Expression, with field:" << std::endl << indent;
    749631                safe_print( node->member );
    750                 os << endl << indent-1 << "... from aggregate:" << endl << indent;
     632                os << std::endl << indent-1 << "... from aggregate:" << std::endl << indent;
    751633                safe_print( node->aggregate );
    752634                --indent;
    … …  
    777659
    778660        virtual const ast::Expr * visit( const ast::SizeofExpr * node ) {
    779                 os << "Sizeof Expression on: ";
    780                 ++indent;
    781                 if ( node->type ) node->type->accept( *this );
    782                 else safe_print( node->expr );
    783                 --indent;
    784                 postprint( node );
    785 
    786661                return node;
    787662        }
    788663
    789664        virtual const ast::Expr * visit( const ast::AlignofExpr * node ) {
    790                 os << "Alignof Expression on: ";
    791                 ++indent;
    792                 if ( node->type ) node->type->accept( *this );
    793                 else safe_print( node->expr );
    794                 --indent;
    795                 postprint( node );
    796                
    797665                return node;
    798666        }
    799667
    800668        virtual const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) {
    801                 os << "Untyped Offsetof Expression on member " << node->member << " of ";
    802                 ++indent;
    803                 safe_print( node->type );
    804                 --indent;
    805                 postprint( node );
    806 
    807669                return node;
    808670        }
    809671
    810672        virtual const ast::Expr * visit( const ast::OffsetofExpr * node ) {
    811                 os << "Offsetof Expression on member " << node->member->name << " of ";
    812                 ++indent;
    813                 safe_print( node->type );
    814                 --indent;
    815                 postprint( node );
    816 
    817673                return node;
    818674        }
    819675
    820676        virtual const ast::Expr * visit( const ast::OffsetPackExpr * node ) {
    821                 os << "Offset Pack Expression on: ";
    822                 ++indent;
    823                 safe_print( node->type );
    824                 --indent;
    825                 postprint( node );
    826 
    827677                return node;
    828678        }
    829679
    830680        virtual const ast::Expr * visit( const ast::LogicalExpr * node ) {
    831                 os << "Short-circuited operation (" << (node->isAnd ? "and" : "or") << ") on: ";
    832                 safe_print( node->arg1 );
    833                 os << " and ";
    834                 safe_print( node->arg2 );
    835                 postprint( node );
    836 
    837681                return node;
    838682        }
    839683
    840684        virtual const ast::Expr * visit( const ast::ConditionalExpr * node ) {
    841                 ++indent;
    842                 os << "Conditional expression on:" << endl << indent;
    843                 safe_print( node->arg1 );
    844                 os << indent-1 << "First alternative:" << endl << indent;
    845                 safe_print( node->arg2 );
    846                 os << indent-1 << "Second alternative:" << endl << indent;
    847                 safe_print( node->arg3 );
    848                 --indent;
    849                 postprint( node );
    850 
    851685                return node;
    852686        }
    853687
    854688        virtual const ast::Expr * visit( const ast::CommaExpr * node ) {
    855                 ++indent;
    856                 os << "Comma Expression:" << endl << indent;
    857                 safe_print( node->arg1 );
    858                 os << endl << indent;
    859                 safe_print( node->arg2 );
    860                 --indent;
    861                 postprint( node );
    862 
    863689                return node;
    864690        }
    865691
    866692        virtual const ast::Expr * visit( const ast::TypeExpr * node ) {
    867                 safe_print( node->type );
    868                 postprint( node );
    869 
    870693                return node;
    871694        }
    872695
    873696        virtual const ast::Expr * visit( const ast::AsmExpr * node ) {
    874                 os << "Asm Expression:" << endl;
    875                 ++indent;
    876                 if ( node->inout ) node->inout->accept( *this );
    877                 if ( node->constraint ) node->constraint->accept( *this );
    878                 if ( node->operand ) node->operand->accept( *this );
    879                 --indent;
    880                
    881697                return node;
    882698        }
    883699
    884700        virtual const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) {
    885                 ++indent;
    886                 os << "Implicit Copy Constructor Expression:" << endl << indent;
    887                 safe_print( node->callExpr );
    888                 os << endl << indent-1 << "... with temporaries:" << endl;
    889                 printAll( node->tempDecls );
    890                 os << endl << indent-1 << "... with return temporaries:" << endl;
    891                 printAll( node->returnDecls );
    892                 --indent;
    893                 postprint( node );
    894 
    895701                return node;
    896702        }
    897703
    898704        virtual const ast::Expr * visit( const ast::ConstructorExpr * node ) {
    899                 os <<  "Constructor Expression:" << endl << indent+1;
    900                 indent += 2;
    901                 safe_print( node->callExpr );
    902                 indent -= 2;
    903                 postprint( node );
    904 
    905705                return node;
    906706        }
    907707
    908708        virtual const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) {
    909                 ++indent;
    910                 os << "Compound Literal Expression: " << endl << indent;
    911                 safe_print( node->result );
    912                 os << indent;
    913                 safe_print( node->init );
    914                 --indent;
    915                 postprint( node );
    916 
    917709                return node;
    918710        }
    919711
    920712        virtual const ast::Expr * visit( const ast::RangeExpr * node ) {
    921                 os << "Range Expression: ";
    922                 safe_print( node->low );
    923                 os << " ... ";
    924                 safe_print( node->high );
    925                 postprint( node );
    926 
    927713                return node;
    928714        }
    929715
    930716        virtual const ast::Expr * visit( const ast::UntypedTupleExpr * node ) {
    931                 os << "Untyped Tuple:" << endl;
    932                 ++indent;
    933                 printAll( node->exprs );
    934                 --indent;
    935                 postprint( node );
    936 
    937717                return node;
    938718        }
    939719
    940720        virtual const ast::Expr * visit( const ast::TupleExpr * node ) {
    941                 os << "Tuple:" << endl;
    942                 ++indent;
    943                 printAll( node->exprs );
    944                 --indent;
    945                 postprint( node );
    946 
    947721                return node;
    948722        }
    949723
    950724        virtual const ast::Expr * visit( const ast::TupleIndexExpr * node ) {
    951                 os << "Tuple Index Expression, with tuple:" << endl;
    952                 ++indent;
    953                 os << indent;
    954                 safe_print( node->tuple );
    955                 os << indent << "with index: " << node->index << endl;
    956                 --indent;
    957                 postprint( node );
    958                
    959725                return node;
    960726        }
    961727
    962728        virtual const ast::Expr * visit( const ast::TupleAssignExpr * node ) {
    963                 os << "Tuple Assignment Expression, with stmt expr:" << endl;
    964                 ++indent;
    965                 os << indent;
    966                 safe_print( node->stmtExpr );
    967                 --indent;
    968                 postprint( node );
    969 
    970729                return node;
    971730        }
    972731
    973732        virtual const ast::Expr * visit( const ast::StmtExpr * node ) {
    974                 ++indent;
    975                 os << "Statement Expression:" << endl << indent;
    976                 safe_print( node->stmts );
    977                 if ( ! node->returnDecls.empty() ) {
    978                         os << indent << "... with returnDecls: ";
    979                         printAll( node->returnDecls );
    980                 }
    981                 if ( ! node->dtors.empty() ) {
    982                         os << indent << "... with dtors: ";
    983                         printAll( node->dtors );
    984                 }
    985                 --indent;
    986                 postprint( node );
    987 
    988733                return node;
    989734        }
    990735
    991736        virtual const ast::Expr * visit( const ast::UniqueExpr * node ) {
    992                 ++indent;
    993                 os << "Unique Expression with id: " << node->id << endl << indent;
    994                 safe_print( node->expr );
    995                 if ( node->object ) {
    996                         os << indent-1 << "... with decl: ";
    997                         short_print( node->object );
    998                 }
    999                 --indent;
    1000                 postprint( node );
    1001 
    1002737                return node;
    1003738        }
    1004739
    1005740        virtual const ast::Expr * visit( const ast::UntypedInitExpr * node ) {
    1006                 ++indent;
    1007                 os << "Untyped Init Expression" << endl << indent;
    1008                 safe_print( node->expr );
    1009                 if ( ! node->initAlts.empty() ) {
    1010                         for ( const InitAlternative & alt : node->initAlts ) {
    1011                                 os << indent <<  "InitAlternative: ";
    1012                                 safe_print( alt.type );
    1013                                 safe_print( alt.designation );
    1014                         }
    1015                 }
    1016                 --indent;
    1017 
    1018741                return node;
    1019742        }
    1020743
    1021744        virtual const ast::Expr * visit( const ast::InitExpr * node ) {
    1022                 ++indent;
    1023                 os << "Init Expression" << endl << indent;
    1024                 safe_print( node->expr );
    1025                 os << indent << "... with designation: ";
    1026                 safe_print( node->designation );
    1027                 --indent;
    1028 
    1029745                return node;
    1030746        }
    1031747
    1032748        virtual const ast::Expr * visit( const ast::DeletedExpr * node ) {
    1033                 ++indent;
    1034                 os << "Deleted Expression" << endl << indent;
    1035                 safe_print( node->expr );
    1036                 os << endl << indent << "... deleted by: ";
    1037                 safe_print( node->deleteStmt );
    1038                 --indent;
    1039 
    1040749                return node;
    1041750        }
    1042751
    1043752        virtual const ast::Expr * visit( const ast::DefaultArgExpr * node ) {
    1044                 ++indent;
    1045                 os << "Default Argument Expression" << endl << indent;
    1046                 safe_print( node->expr );
    1047                 --indent;
    1048 
    1049753                return node;
    1050754        }
    1051755
    1052756        virtual const ast::Expr * visit( const ast::GenericExpr * node ) {
    1053                 ++indent;
    1054                 os << "C11 _Generic Expression" << endl << indent;
    1055                 safe_print( node->control );
    1056                 os << endl << indent << "... with associations:" << endl;
    1057                 for ( const auto & assoc : node->associations ) {
    1058                         os << indent;
    1059                         if ( assoc.type ) {
    1060                                 os << "... type: ";
    1061                                 assoc.type->accept( *this );
    1062                                 os << endl << indent << "... expression: ";
    1063                                 safe_print( assoc.expr );
    1064                         } else {
    1065                                 os << "... default: ";
    1066                                 safe_print( assoc.expr );
    1067                         }
    1068                         os << endl;
    1069                 }
    1070                 --indent;
    1071 
    1072757                return node;
    1073758        }
    … …  
    1143828                preprint( node );
    1144829                ++indent;
    1145                 os << "Qualified Type:" << endl << indent;
     830                os << "Qualified Type:" << std::endl << indent;
    1146831                safe_print( node->parent );
    1147                 os << endl << indent;
     832                os << std::endl << indent;
    1148833                safe_print( node->child );
    1149                 os << endl;
     834                os << std::endl;
    1150835                --indent;
    1151836
    … …  
    1156841                preprint( node );
    1157842               
    1158                 os << "function" << endl;
     843                os << "function" << std::endl;
    1159844                if ( ! node->params.empty() ) {
    1160                         os << indent << "... with parameters" << endl;
     845                        os << indent << "... with parameters" << std::endl;
    1161846                        ++indent;
    1162847                        printAll( node->params );
    1163848                        if ( node->isVarArgs ) {
    1164                                 os << indent << "and a variable number of other arguments" << endl;
     849                                os << indent << "and a variable number of other arguments" << std::endl;
    1165850                        }
    1166851                        --indent;
    1167852                } else if ( node->isVarArgs ) {
    1168                         os << indent+1 << "accepting unspecified arguments" << endl;
     853                        os << indent+1 << "accepting unspecified arguments" << std::endl;
    1169854                }
    1170855
    1171856                os << indent << "... returning";
    1172857                if ( node->returns.empty() ) {
    1173                         os << " nothing" << endl;
     858                        os << " nothing" << std::endl;
    1174859                } else {
    1175                         os << endl;
     860                        os << std::endl;
    1176861                        ++indent;
    1177862                        printAll( node->returns );
    … …  
    1234919        virtual const ast::Type * visit( const ast::TupleType * node ) {
    1235920                preprint( node );
    1236                 os << "tuple of types" << endl;
     921                os << "tuple of types" << std::endl;
    1237922                ++indent;
    1238923                printAll( node->types );
    … …  
    1277962        virtual const ast::Designation * visit( const ast::Designation * node ) {
    1278963                if ( node->designators.empty() ) return node;
    1279                 os << "... designated by: " << endl;
     964                os << "... designated by: " << std::endl;
    1280965                ++indent;
    1281966                for ( const ast::Expr * d : node->designators ) {
    1282967                        os << indent;
    1283968                        d->accept( *this );
    1284                         os << endl;
     969                        os << std::endl;
    1285970                }
    1286971                --indent;
    … …  
    1295980
    1296981        virtual const ast::Init * visit( const ast::ListInit * node ) {
    1297                 os << "Compound initializer: " << endl;
     982                os << "Compound initializer: " << std::endl;
    1298983                ++indent;
    1299984                for ( auto p : group_iterate( node->designations, node->initializers ) ) {
    … …  
    1302987                        os << indent;
    1303988                        init->accept( *this );
    1304                         os << endl;
     989                        os << std::endl;
    1305990                        if ( ! d->designators.empty() ) {
    1306991                                os << indent;
    … …  
    1313998
    1314999        virtual const ast::Init * visit( const ast::ConstructorInit * node ) {
    1315                 os << "Constructor initializer: " << endl;
     1000                os << "Constructor initializer: " << std::endl;
    13161001                if ( node->ctor ) {
    13171002                        os << indent << "... initially constructed with ";
    … …  
    13411026                os << "Attribute with name: " << node->name;
    13421027                if ( node->params.empty() ) return node;
    1343                 os << " with parameters: " << endl;
     1028                os << " with parameters: " << std::endl;
    13441029                ++indent;
    13451030                printAll( node->params );
    … …  
    13491034
    13501035        virtual const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) {
    1351                 os << indent << "Types:" << endl;
     1036                os << indent << "Types:" << std::endl;
    13521037                for ( const auto& i : *node ) {
    13531038                        os << indent+1 << i.first << " -> ";
    … …  
    13551040                        safe_print( i.second );
    13561041                        indent -= 2;
    1357                         os << endl;
    1358                 }
    1359                 os << indent << "Non-types:" << endl;
     1042                        os << std::endl;
     1043                }
     1044                os << indent << "Non-types:" << std::endl;
    13601045                for ( auto i = node->beginVar(); i != node->endVar(); ++i ) {
    13611046                        os << indent+1 << i->first << " -> ";
    … …  
    13631048                        safe_print( i->second );
    13641049                        indent -= 2;
    1365                         os << endl;
     1050                        os << std::endl;
    13661051                }
    13671052                return node;

  • src/AST/Stmt.hpp

    r21a44ca rf1ec88a  
    244244          computedTarget(computedTarget), kind(Goto) {}
    245245
    246         const char * kindName() const { return kindNames[kind]; }
     246        const char * kindName() { return kindNames[kind]; }
    247247
    248248        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
Note: See TracChangeset for help on using the changeset viewer.