Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Visitor.h

    r033ff37 rd807ca28  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 25 22:21:49 2019
    13 // Update Count     : 14
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Mon Jul 24 16:28:00 2017
     13// Update Count     : 13
    1414//
    1515
    … …  
    2727        // of the given syntax node, but performs no other action.
    2828
    29         virtual void visit( ObjectDecl * node ) { visit( const_cast<const ObjectDecl *>(node) ); }
    30         virtual void visit( const ObjectDecl * objectDecl ) = 0;
    31         virtual void visit( FunctionDecl * node ) { visit( const_cast<const FunctionDecl *>(node) ); }
    32         virtual void visit( const FunctionDecl * functionDecl ) = 0;
    33         virtual void visit( StructDecl * node ) { visit( const_cast<const StructDecl *>(node) ); }
    34         virtual void visit( const StructDecl * aggregateDecl ) = 0;
    35         virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
    36         virtual void visit( const UnionDecl * aggregateDecl ) = 0;
    37         virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
    38         virtual void visit( const EnumDecl * aggregateDecl ) = 0;
    39         virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
    40         virtual void visit( const TraitDecl * aggregateDecl ) = 0;
    41         virtual void visit( TypeDecl * node ) { visit( const_cast<const TypeDecl *>(node) ); }
    42         virtual void visit( const TypeDecl * typeDecl ) = 0;
    43         virtual void visit( TypedefDecl * node ) { visit( const_cast<const TypedefDecl *>(node) ); }
    44         virtual void visit( const TypedefDecl * typeDecl ) = 0;
    45         virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
    46         virtual void visit( const AsmDecl * asmDecl ) = 0;
    47         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
    48         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
     29        virtual void visit( ObjectDecl * objectDecl ) = 0;
     30        virtual void visit( FunctionDecl * functionDecl ) = 0;
     31        virtual void visit( StructDecl * aggregateDecl ) = 0;
     32        virtual void visit( UnionDecl * aggregateDecl ) = 0;
     33        virtual void visit( EnumDecl * aggregateDecl ) = 0;
     34        virtual void visit( TraitDecl * aggregateDecl ) = 0;
     35        virtual void visit( TypeDecl * typeDecl ) = 0;
     36        virtual void visit( TypedefDecl * typeDecl ) = 0;
     37        virtual void visit( AsmDecl * asmDecl ) = 0;
     38        virtual void visit( StaticAssertDecl * assertDecl ) = 0;
    4939
    50         virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }
    51         virtual void visit( const CompoundStmt * compoundStmt ) = 0;
    52         virtual void visit( ExprStmt * node ) { visit( const_cast<const ExprStmt *>(node) ); }
    53         virtual void visit( const ExprStmt * exprStmt ) = 0;
    54         virtual void visit( AsmStmt * node ) { visit( const_cast<const AsmStmt *>(node) ); }
    55         virtual void visit( const AsmStmt * asmStmt ) = 0;
    56         virtual void visit( DirectiveStmt * node ) { visit( const_cast<const DirectiveStmt *>(node) ); }
    57         virtual void visit( const DirectiveStmt * directiveStmt ) = 0;
    58         virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
    59         virtual void visit( const IfStmt * ifStmt ) = 0;
    60         virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
    61         virtual void visit( const WhileStmt * whileStmt ) = 0;
    62         virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
    63         virtual void visit( const ForStmt * forStmt ) = 0;
    64         virtual void visit( SwitchStmt * node ) { visit( const_cast<const SwitchStmt *>(node) ); }
    65         virtual void visit( const SwitchStmt * switchStmt ) = 0;
    66         virtual void visit( CaseStmt * node ) { visit( const_cast<const CaseStmt *>(node) ); }
    67         virtual void visit( const CaseStmt * caseStmt ) = 0;
    68         virtual void visit( BranchStmt * node ) { visit( const_cast<const BranchStmt *>(node) ); }
    69         virtual void visit( const BranchStmt * branchStmt ) = 0;
    70         virtual void visit( ReturnStmt * node ) { visit( const_cast<const ReturnStmt *>(node) ); }
    71         virtual void visit( const ReturnStmt * returnStmt ) = 0;
    72         virtual void visit( ThrowStmt * node ) { visit( const_cast<const ThrowStmt *>(node) ); }
    73         virtual void visit( const ThrowStmt * throwStmt ) = 0;
    74         virtual void visit( TryStmt * node ) { visit( const_cast<const TryStmt *>(node) ); }
    75         virtual void visit( const TryStmt * tryStmt ) = 0;
    76         virtual void visit( CatchStmt * node ) { visit( const_cast<const CatchStmt *>(node) ); }
    77         virtual void visit( const CatchStmt * catchStmt ) = 0;
    78         virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
    79         virtual void visit( const FinallyStmt * finallyStmt ) = 0;
    80         virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
    81         virtual void visit( const WaitForStmt * waitforStmt ) = 0;
    82         virtual void visit( WithStmt * node ) { visit( const_cast<const WithStmt *>(node) ); }
    83         virtual void visit( const WithStmt * withStmt ) = 0;
    84         virtual void visit( NullStmt * node ) { visit( const_cast<const NullStmt *>(node) ); }
    85         virtual void visit( const NullStmt * nullStmt ) = 0;
    86         virtual void visit( DeclStmt * node ) { visit( const_cast<const DeclStmt *>(node) ); }
    87         virtual void visit( const DeclStmt * declStmt ) = 0;
    88         virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
    89         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     40        virtual void visit( CompoundStmt * compoundStmt ) = 0;
     41        virtual void visit( ExprStmt * exprStmt ) = 0;
     42        virtual void visit( AsmStmt * asmStmt ) = 0;
     43        virtual void visit( DirectiveStmt * directiveStmt ) = 0;
     44        virtual void visit( IfStmt * ifStmt ) = 0;
     45        virtual void visit( WhileStmt * whileStmt ) = 0;
     46        virtual void visit( ForStmt * forStmt ) = 0;
     47        virtual void visit( SwitchStmt * switchStmt ) = 0;
     48        virtual void visit( CaseStmt * caseStmt ) = 0;
     49        virtual void visit( BranchStmt * branchStmt ) = 0;
     50        virtual void visit( ReturnStmt * returnStmt ) = 0;
     51        virtual void visit( ThrowStmt * throwStmt ) = 0;
     52        virtual void visit( TryStmt * tryStmt ) = 0;
     53        virtual void visit( CatchStmt * catchStmt ) = 0;
     54        virtual void visit( FinallyStmt * finallyStmt ) = 0;
     55        virtual void visit( WaitForStmt * waitforStmt ) = 0;
     56        virtual void visit( WithStmt * withStmt ) = 0;
     57        virtual void visit( NullStmt * nullStmt ) = 0;
     58        virtual void visit( DeclStmt * declStmt ) = 0;
     59        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
    9060
    91         virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }
    92         virtual void visit( const ApplicationExpr * applicationExpr ) = 0;
    93         virtual void visit( UntypedExpr * node ) { visit( const_cast<const UntypedExpr *>(node) ); }
    94         virtual void visit( const UntypedExpr * untypedExpr ) = 0;
    95         virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
    96         virtual void visit( const NameExpr * nameExpr ) = 0;
    97         virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
    98         virtual void visit( const CastExpr * castExpr ) = 0;
    99         virtual void visit( KeywordCastExpr * node ) { visit( const_cast<const KeywordCastExpr *>(node) ); }
    100         virtual void visit( const KeywordCastExpr * castExpr ) = 0;
    101         virtual void visit( VirtualCastExpr * node ) { visit( const_cast<const VirtualCastExpr *>(node) ); }
    102         virtual void visit( const VirtualCastExpr * castExpr ) = 0;
    103         virtual void visit( AddressExpr * node ) { visit( const_cast<const AddressExpr *>(node) ); }
    104         virtual void visit( const AddressExpr * addressExpr ) = 0;
    105         virtual void visit( LabelAddressExpr * node ) { visit( const_cast<const LabelAddressExpr *>(node) ); }
    106         virtual void visit( const LabelAddressExpr * labAddressExpr ) = 0;
    107         virtual void visit( UntypedMemberExpr * node ) { visit( const_cast<const UntypedMemberExpr *>(node) ); }
    108         virtual void visit( const UntypedMemberExpr * memberExpr ) = 0;
    109         virtual void visit( MemberExpr * node ) { visit( const_cast<const MemberExpr *>(node) ); }
    110         virtual void visit( const MemberExpr * memberExpr ) = 0;
    111         virtual void visit( VariableExpr * node ) { visit( const_cast<const VariableExpr *>(node) ); }
    112         virtual void visit( const VariableExpr * variableExpr ) = 0;
    113         virtual void visit( ConstantExpr * node ) { visit( const_cast<const ConstantExpr *>(node) ); }
    114         virtual void visit( const ConstantExpr * constantExpr ) = 0;
    115         virtual void visit( SizeofExpr * node ) { visit( const_cast<const SizeofExpr *>(node) ); }
    116         virtual void visit( const SizeofExpr * sizeofExpr ) = 0;
    117         virtual void visit( AlignofExpr * node ) { visit( const_cast<const AlignofExpr *>(node) ); }
    118         virtual void visit( const AlignofExpr * alignofExpr ) = 0;
    119         virtual void visit( UntypedOffsetofExpr * node ) { visit( const_cast<const UntypedOffsetofExpr *>(node) ); }
    120         virtual void visit( const UntypedOffsetofExpr * offsetofExpr ) = 0;
    121         virtual void visit( OffsetofExpr * node ) { visit( const_cast<const OffsetofExpr *>(node) ); }
    122         virtual void visit( const OffsetofExpr * offsetofExpr ) = 0;
    123         virtual void visit( OffsetPackExpr * node ) { visit( const_cast<const OffsetPackExpr *>(node) ); }
    124         virtual void visit( const OffsetPackExpr * offsetPackExpr ) = 0;
    125         virtual void visit( LogicalExpr * node ) { visit( const_cast<const LogicalExpr *>(node) ); }
    126         virtual void visit( const LogicalExpr * logicalExpr ) = 0;
    127         virtual void visit( ConditionalExpr * node ) { visit( const_cast<const ConditionalExpr *>(node) ); }
    128         virtual void visit( const ConditionalExpr * conditionalExpr ) = 0;
    129         virtual void visit( CommaExpr * node ) { visit( const_cast<const CommaExpr *>(node) ); }
    130         virtual void visit( const CommaExpr * commaExpr ) = 0;
    131         virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
    132         virtual void visit( const TypeExpr * typeExpr ) = 0;
    133         virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
    134         virtual void visit( const AsmExpr * asmExpr ) = 0;
    135         virtual void visit( ImplicitCopyCtorExpr * node ) { visit( const_cast<const ImplicitCopyCtorExpr *>(node) ); }
    136         virtual void visit( const ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
    137         virtual void visit( ConstructorExpr * node ) { visit( const_cast<const ConstructorExpr *>(node) ); }
    138         virtual void visit( const ConstructorExpr *  ctorExpr ) = 0;
    139         virtual void visit( CompoundLiteralExpr * node ) { visit( const_cast<const CompoundLiteralExpr *>(node) ); }
    140         virtual void visit( const CompoundLiteralExpr * compLitExpr ) = 0;
    141         virtual void visit( RangeExpr * node ) { visit( const_cast<const RangeExpr *>(node) ); }
    142         virtual void visit( const RangeExpr * rangeExpr ) = 0;
    143         virtual void visit( UntypedTupleExpr * node ) { visit( const_cast<const UntypedTupleExpr *>(node) ); }
    144         virtual void visit( const UntypedTupleExpr * tupleExpr ) = 0;
    145         virtual void visit( TupleExpr * node ) { visit( const_cast<const TupleExpr *>(node) ); }
    146         virtual void visit( const TupleExpr * tupleExpr ) = 0;
    147         virtual void visit( TupleIndexExpr * node ) { visit( const_cast<const TupleIndexExpr *>(node) ); }
    148         virtual void visit( const TupleIndexExpr * tupleExpr ) = 0;
    149         virtual void visit( TupleAssignExpr * node ) { visit( const_cast<const TupleAssignExpr *>(node) ); }
    150         virtual void visit( const TupleAssignExpr * assignExpr ) = 0;
    151         virtual void visit( StmtExpr * node ) { visit( const_cast<const StmtExpr *>(node) ); }
    152         virtual void visit( const StmtExpr *  stmtExpr ) = 0;
    153         virtual void visit( UniqueExpr * node ) { visit( const_cast<const UniqueExpr *>(node) ); }
    154         virtual void visit( const UniqueExpr *  uniqueExpr ) = 0;
    155         virtual void visit( UntypedInitExpr * node ) { visit( const_cast<const UntypedInitExpr *>(node) ); }
    156         virtual void visit( const UntypedInitExpr *  initExpr ) = 0;
    157         virtual void visit( InitExpr * node ) { visit( const_cast<const InitExpr *>(node) ); }
    158         virtual void visit( const InitExpr *  initExpr ) = 0;
    159         virtual void visit( DeletedExpr * node ) { visit( const_cast<const DeletedExpr *>(node) ); }
    160         virtual void visit( const DeletedExpr * delExpr ) = 0;
    161         virtual void visit( DefaultArgExpr * node ) { visit( const_cast<const DefaultArgExpr *>(node) ); }
    162         virtual void visit( const DefaultArgExpr * argExpr ) = 0;
    163         virtual void visit( GenericExpr * node ) { visit( const_cast<const GenericExpr *>(node) ); }
    164         virtual void visit( const GenericExpr * genExpr ) = 0;
     61        virtual void visit( ApplicationExpr * applicationExpr ) = 0;
     62        virtual void visit( UntypedExpr * untypedExpr ) = 0;
     63        virtual void visit( NameExpr * nameExpr ) = 0;
     64        virtual void visit( CastExpr * castExpr ) = 0;
     65        virtual void visit( KeywordCastExpr * castExpr ) = 0;
     66        virtual void visit( VirtualCastExpr * castExpr ) = 0;
     67        virtual void visit( AddressExpr * addressExpr ) = 0;
     68        virtual void visit( LabelAddressExpr * labAddressExpr ) = 0;
     69        virtual void visit( UntypedMemberExpr * memberExpr ) = 0;
     70        virtual void visit( MemberExpr * memberExpr ) = 0;
     71        virtual void visit( VariableExpr * variableExpr ) = 0;
     72        virtual void visit( ConstantExpr * constantExpr ) = 0;
     73        virtual void visit( SizeofExpr * sizeofExpr ) = 0;
     74        virtual void visit( AlignofExpr * alignofExpr ) = 0;
     75        virtual void visit( UntypedOffsetofExpr * offsetofExpr ) = 0;
     76        virtual void visit( OffsetofExpr * offsetofExpr ) = 0;
     77        virtual void visit( OffsetPackExpr * offsetPackExpr ) = 0;
     78        virtual void visit( AttrExpr * attrExpr ) = 0;
     79        virtual void visit( LogicalExpr * logicalExpr ) = 0;
     80        virtual void visit( ConditionalExpr * conditionalExpr ) = 0;
     81        virtual void visit( CommaExpr * commaExpr ) = 0;
     82        virtual void visit( TypeExpr * typeExpr ) = 0;
     83        virtual void visit( AsmExpr * asmExpr ) = 0;
     84        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
     85        virtual void visit( ConstructorExpr *  ctorExpr ) = 0;
     86        virtual void visit( CompoundLiteralExpr * compLitExpr ) = 0;
     87        virtual void visit( RangeExpr * rangeExpr ) = 0;
     88        virtual void visit( UntypedTupleExpr * tupleExpr ) = 0;
     89        virtual void visit( TupleExpr * tupleExpr ) = 0;
     90        virtual void visit( TupleIndexExpr * tupleExpr ) = 0;
     91        virtual void visit( TupleAssignExpr * assignExpr ) = 0;
     92        virtual void visit( StmtExpr *  stmtExpr ) = 0;
     93        virtual void visit( UniqueExpr *  uniqueExpr ) = 0;
     94        virtual void visit( UntypedInitExpr *  initExpr ) = 0;
     95        virtual void visit( InitExpr *  initExpr ) = 0;
     96        virtual void visit( DeletedExpr * delExpr ) = 0;
     97        virtual void visit( GenericExpr * genExpr ) = 0;
    16598
    166         virtual void visit( VoidType * node ) { visit( const_cast<const VoidType *>(node) ); }
    167         virtual void visit( const VoidType * basicType ) = 0;
    168         virtual void visit( BasicType * node ) { visit( const_cast<const BasicType *>(node) ); }
    169         virtual void visit( const BasicType * basicType ) = 0;
    170         virtual void visit( PointerType * node ) { visit( const_cast<const PointerType *>(node) ); }
    171         virtual void visit( const PointerType * pointerType ) = 0;
    172         virtual void visit( ArrayType * node ) { visit( const_cast<const ArrayType *>(node) ); }
    173         virtual void visit( const ArrayType * arrayType ) = 0;
    174         virtual void visit( ReferenceType * node ) { visit( const_cast<const ReferenceType *>(node) ); }
    175         virtual void visit( const ReferenceType * refType ) = 0;
    176         virtual void visit( QualifiedType * node ) { visit( const_cast<const QualifiedType *>(node) ); }
    177         virtual void visit( const QualifiedType * qualType ) = 0;
    178         virtual void visit( FunctionType * node ) { visit( const_cast<const FunctionType *>(node) ); }
    179         virtual void visit( const FunctionType * functionType ) = 0;
    180         virtual void visit( StructInstType * node ) { visit( const_cast<const StructInstType *>(node) ); }
    181         virtual void visit( const StructInstType * aggregateUseType ) = 0;
    182         virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
    183         virtual void visit( const UnionInstType * aggregateUseType ) = 0;
    184         virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
    185         virtual void visit( const EnumInstType * aggregateUseType ) = 0;
    186         virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }
    187         virtual void visit( const TraitInstType * aggregateUseType ) = 0;
    188         virtual void visit( TypeInstType * node ) { visit( const_cast<const TypeInstType *>(node) ); }
    189         virtual void visit( const TypeInstType * aggregateUseType ) = 0;
    190         virtual void visit( TupleType * node ) { visit( const_cast<const TupleType *>(node) ); }
    191         virtual void visit( const TupleType * tupleType ) = 0;
    192         virtual void visit( TypeofType * node ) { visit( const_cast<const TypeofType *>(node) ); }
    193         virtual void visit( const TypeofType * typeofType ) = 0;
    194         virtual void visit( AttrType * node ) { visit( const_cast<const AttrType *>(node) ); }
    195         virtual void visit( const AttrType * attrType ) = 0;
    196         virtual void visit( VarArgsType * node ) { visit( const_cast<const VarArgsType *>(node) ); }
    197         virtual void visit( const VarArgsType * varArgsType ) = 0;
    198         virtual void visit( ZeroType * node ) { visit( const_cast<const ZeroType *>(node) ); }
    199         virtual void visit( const ZeroType * zeroType ) = 0;
    200         virtual void visit( OneType * node ) { visit( const_cast<const OneType *>(node) ); }
    201         virtual void visit( const OneType * oneType ) = 0;
    202         virtual void visit( GlobalScopeType * node ) { visit( const_cast<const GlobalScopeType *>(node) ); }
    203         virtual void visit( const GlobalScopeType * globalType ) = 0;
     99        virtual void visit( VoidType * basicType ) = 0;
     100        virtual void visit( BasicType * basicType ) = 0;
     101        virtual void visit( PointerType * pointerType ) = 0;
     102        virtual void visit( ArrayType * arrayType ) = 0;
     103        virtual void visit( ReferenceType * refType ) = 0;
     104        virtual void visit( FunctionType * functionType ) = 0;
     105        virtual void visit( StructInstType * aggregateUseType ) = 0;
     106        virtual void visit( UnionInstType * aggregateUseType ) = 0;
     107        virtual void visit( EnumInstType * aggregateUseType ) = 0;
     108        virtual void visit( TraitInstType * aggregateUseType ) = 0;
     109        virtual void visit( TypeInstType * aggregateUseType ) = 0;
     110        virtual void visit( TupleType * tupleType ) = 0;
     111        virtual void visit( TypeofType * typeofType ) = 0;
     112        virtual void visit( AttrType * attrType ) = 0;
     113        virtual void visit( VarArgsType * varArgsType ) = 0;
     114        virtual void visit( ZeroType * zeroType ) = 0;
     115        virtual void visit( OneType * oneType ) = 0;
    204116
    205         virtual void visit( Designation * node ) { visit( const_cast<const Designation *>(node) ); }
    206         virtual void visit( const Designation * designation ) = 0;
    207         virtual void visit( SingleInit * node ) { visit( const_cast<const SingleInit *>(node) ); }
    208         virtual void visit( const SingleInit * singleInit ) = 0;
    209         virtual void visit( ListInit * node ) { visit( const_cast<const ListInit *>(node) ); }
    210         virtual void visit( const ListInit * listInit ) = 0;
    211         virtual void visit( ConstructorInit * node ) { visit( const_cast<const ConstructorInit *>(node) ); }
    212         virtual void visit( const ConstructorInit * ctorInit ) = 0;
     117        virtual void visit( Designation * designation ) = 0;
     118        virtual void visit( SingleInit * singleInit ) = 0;
     119        virtual void visit( ListInit * listInit ) = 0;
     120        virtual void visit( ConstructorInit * ctorInit ) = 0;
    213121
    214         virtual void visit( Constant * node ) { visit( const_cast<const Constant *>(node) ); }
    215         virtual void visit( const Constant * constant ) = 0;
     122        virtual void visit( Subrange * subrange ) = 0;
    216123
    217         virtual void visit( Attribute * node ) { visit( const_cast<const Attribute *>(node) ); }
    218         virtual void visit( const Attribute * attribute ) = 0;
     124        virtual void visit( Constant * constant ) = 0;
     125
     126        virtual void visit( Attribute * attribute ) = 0;
    219127};
    220128
    221129template< typename TreeType, typename VisitorType >
    222 inline void maybeAccept( TreeType * tree, VisitorType & visitor ) {
    223         if ( tree ) {
    224                 tree->accept( visitor );
    225         }
    226 }
    227 
    228 template< typename TreeType, typename VisitorType >
    229 inline void maybeAccept( const TreeType * tree, VisitorType & visitor ) {
     130inline void maybeAccept( TreeType *tree, VisitorType &visitor ) {
    230131        if ( tree ) {
    231132                tree->accept( visitor );
    … …  
    234135
    235136template< typename Container, typename VisitorType >
    236 inline void acceptAll( Container & container, VisitorType & visitor ) {
     137inline void acceptAll( Container &container, VisitorType &visitor ) {
    237138        SemanticErrorException errors;
    238         for ( auto * i : container ) {
     139        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
    239140                try {
    240                         if ( i ) {
    241                                 i->accept( visitor );
    242                         }
    243                 } catch( SemanticErrorException & e ) {
    244                         errors.append( e );
    245                 }
    246         }
    247         if ( ! errors.isEmpty() ) {
    248                 throw errors;
    249         }
    250 }
    251 
    252 template< typename Container, typename VisitorType >
    253 inline void acceptAll( const Container & container, VisitorType & visitor ) {
    254         SemanticErrorException errors;
    255         for ( const auto * i : container ) {
    256                 try {
    257                         if ( i ) {
    258                                 i->accept( visitor );
     141                        if ( *i ) {
     142                                (*i)->accept( visitor );
    259143                        }
    260144                } catch( SemanticErrorException &e ) {
Note: See TracChangeset for help on using the changeset viewer.