Changeset ea156ae for src/SynTree


Ignore:
Timestamp:
Sep 27, 2017, 5:31:02 PM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
549c006
Parents:
12914e9 (diff), fa16264 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src/SynTree
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Attribute.h

    r12914e9 rea156ae  
    2020#include <string>  // for string, operator==
    2121
     22#include "BaseSyntaxNode.h"
     23#include "Mutator.h"
     24#include "Visitor.h"
     25
    2226class Expression;
    2327
    2428// GCC attribute
    2529// https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Attribute-Syntax.html#Attribute-Syntax
    26 class Attribute {
     30class Attribute : public BaseSyntaxNode {
    2731  public:
     32        std::string name;
     33        // to keep things nice and tight, use NameExpr for special identifier parameters
     34        std::list< Expression * > parameters;
     35
    2836        Attribute( std::string name = "", const std::list< Expression * > & parameters = std::list< Expression * >() ) : name( name ), parameters( parameters ) {}
    2937        Attribute( const Attribute &other );
    … …  
    3543        bool empty() const { return name == ""; }
    3644
    37         Attribute * clone() const { return new Attribute( *this ); }
    38         void print( std:: ostream &os, int indent = 0 ) const;
    39   private:
    40         std::string name;
    41         // to keep things nice and tight, use NameExpr for special identifier parameters
    42         std::list< Expression * > parameters;
     45        Attribute * clone() const override { return new Attribute( *this ); }
     46        virtual void accept( Visitor & v ) override { v.visit( this ); }
     47        virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     48        virtual void print( std::ostream & os, int indent = 0 ) const override;
    4349};
    4450

  • src/SynTree/BaseSyntaxNode.h

    r12914e9 rea156ae  
    1818#include "Common/CodeLocation.h"
    1919class Visitor;
     20class Mutator;
    2021
    2122class BaseSyntaxNode {
    … …  
    2526        virtual ~BaseSyntaxNode() {}
    2627
     28        virtual BaseSyntaxNode * clone() const = 0;
    2729        virtual void accept( Visitor & v ) = 0;
    28         virtual void print( std::ostream & os, int indent = 0 ) const = 0;
     30        virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
     31        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
    2932};
    3033

  • src/SynTree/Declaration.h

    r12914e9 rea156ae  
    6161
    6262        void fixUniqueId( void );
    63         virtual Declaration *clone() const = 0;
     63        virtual Declaration *clone() const override = 0;
    6464        virtual void accept( Visitor &v ) override = 0;
    65         virtual Declaration *acceptMutator( Mutator &m ) = 0;
     65        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
    6666        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
    6767        virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
    … …  
    164164        CompoundStmt *get_statements() const { return statements; }
    165165        void set_statements( CompoundStmt *newValue ) { statements = newValue; }
     166
     167        static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
    166168
    167169        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }

  • src/SynTree/Expression.h

    r12914e9 rea156ae  
    5555        Expression * set_extension( bool exten ) { extension = exten; return this; }
    5656
    57         virtual Expression * clone() const = 0;
    58         virtual void accept( Visitor & v ) = 0;
    59         virtual Expression * acceptMutator( Mutator & m ) = 0;
    60         virtual void print( std::ostream & os, int indent = 0 ) const;
     57        virtual Expression * clone() const override = 0;
     58        virtual void accept( Visitor & v ) override = 0;
     59        virtual Expression * acceptMutator( Mutator & m ) override = 0;
     60        virtual void print( std::ostream & os, int indent = 0 ) const override;
    6161};
    6262

  • src/SynTree/FunctionDecl.cc

    r12914e9 rea156ae  
    2626#include "Statement.h"           // for CompoundStmt
    2727#include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
     28#include "VarExprReplacer.h"
    2829
    2930extern bool translation_unit_nomain;
    … …  
    3940FunctionDecl::FunctionDecl( const FunctionDecl &other )
    4041                : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
     42
     43        VarExprReplacer::DeclMap declMap;
     44        for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
     45                declMap[ std::get<0>(p) ] = std::get<1>(p);
     46        }
     47        for ( auto p : group_iterate( other.type->returnVals, type->returnVals ) ) {
     48                declMap[ std::get<0>(p) ] = std::get<1>(p);
     49        }
     50        if ( ! declMap.empty() ) {
     51                VarExprReplacer replacer( declMap );
     52                accept( replacer );
     53        }
    4154}
    4255
    … …  
    4457        delete type;
    4558        delete statements;
     59}
     60
     61FunctionDecl * FunctionDecl::newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements ) {
     62        return new FunctionDecl( name, Type::StorageClasses(), LinkageSpec::C, type, statements );
    4663}
    4764

  • src/SynTree/Initializer.h

    r12914e9 rea156ae  
    3737        std::list< Expression * > & get_designators() { return designators; }
    3838
    39         virtual Designation * clone() const { return new Designation( *this ); };
     39        virtual Designation * clone() const override { return new Designation( *this ); };
    4040        virtual void accept( Visitor &v ) override { v.visit( this ); }
    41         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
     41        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
    4242        virtual void print( std::ostream &os, int indent = 0 ) const override;
    4343};
    … …  
    5454        bool get_maybeConstructed() { return maybeConstructed; }
    5555
    56         virtual Initializer *clone() const = 0;
     56        virtual Initializer *clone() const override = 0;
    5757        virtual void accept( Visitor &v ) override = 0;
    58         virtual Initializer *acceptMutator( Mutator &m ) = 0;
     58        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
    5959        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
    6060  private:
    … …  
    117117        Statement * ctor;
    118118        Statement * dtor;
     119        // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
     120        // if an appropriate constructor definition is not found by the resolver
     121        Initializer * init;
    119122
    120123        ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
    … …  
    135138
    136139  private:
    137         // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
    138         // if an appropriate constructor definition is not found by the resolver
    139         Initializer * init;
    140140};
    141141

  • src/SynTree/Mutator.cc

    r12914e9 rea156ae  
    1717#include <list>                // for list
    1818
     19#include "Attribute.h"         // for Attribute
    1920#include "Declaration.h"       // for ObjectDecl, Declaration, DeclarationWi...
    2021#include "Expression.h"        // for Expression, ConstantExpr, ConditionalExpr
    … …  
    3637        objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
    3738        objectDecl->set_bitfieldWidth( maybeMutate( objectDecl->get_bitfieldWidth(), *this ) );
     39        mutateAll( objectDecl->attributes, *this );
    3840        return objectDecl;
    3941}
    … …  
    4244        functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
    4345        functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
     46        mutateAll( functionDecl->attributes, *this );
    4447        return functionDecl;
    4548}
    … …  
    618621}
    619622
     623Attribute * Mutator::mutate( Attribute * attribute ) {
     624        mutateAll( attribute->parameters, *this );
     625        return attribute;
     626}
     627
    620628// Local Variables: //
    621629// tab-width: 4 //

  • src/SynTree/Mutator.h

    r12914e9 rea156ae  
    2525        virtual ~Mutator();
    2626  public:
    27         virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
    28         virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
    29         virtual Declaration* mutate( StructDecl *aggregateDecl );
    30         virtual Declaration* mutate( UnionDecl *aggregateDecl );
    31         virtual Declaration* mutate( EnumDecl *aggregateDecl );
    32         virtual Declaration* mutate( TraitDecl *aggregateDecl );
    33         virtual Declaration* mutate( TypeDecl *typeDecl );
    34         virtual Declaration* mutate( TypedefDecl *typeDecl );
    35         virtual AsmDecl* mutate( AsmDecl *asmDecl );
     27        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
     28        virtual DeclarationWithType * mutate( FunctionDecl * functionDecl );
     29        virtual Declaration * mutate( StructDecl * aggregateDecl );
     30        virtual Declaration * mutate( UnionDecl * aggregateDecl );
     31        virtual Declaration * mutate( EnumDecl * aggregateDecl );
     32        virtual Declaration * mutate( TraitDecl * aggregateDecl );
     33        virtual Declaration * mutate( TypeDecl * typeDecl );
     34        virtual Declaration * mutate( TypedefDecl * typeDecl );
     35        virtual AsmDecl * mutate( AsmDecl * asmDecl );
    3636
    37         virtual CompoundStmt* mutate( CompoundStmt *compoundStmt );
    38         virtual Statement* mutate( ExprStmt *exprStmt );
    39         virtual Statement* mutate( AsmStmt *asmStmt );
    40         virtual Statement* mutate( IfStmt *ifStmt );
    41         virtual Statement* mutate( WhileStmt *whileStmt );
    42         virtual Statement* mutate( ForStmt *forStmt );
    43         virtual Statement* mutate( SwitchStmt *switchStmt );
    44         virtual Statement* mutate( CaseStmt *caseStmt );
    45         virtual Statement* mutate( BranchStmt *branchStmt );
    46         virtual Statement* mutate( ReturnStmt *returnStmt );
    47         virtual Statement* mutate( ThrowStmt *throwStmt );
    48         virtual Statement* mutate( TryStmt *tryStmt );
    49         virtual Statement* mutate( CatchStmt *catchStmt );
    50         virtual Statement* mutate( FinallyStmt *catchStmt );
    51         virtual Statement* mutate( WaitForStmt *waitforStmt );
    52         virtual NullStmt* mutate( NullStmt *nullStmt );
    53         virtual Statement* mutate( DeclStmt *declStmt );
    54         virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt );
     37        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
     38        virtual Statement * mutate( ExprStmt * exprStmt );
     39        virtual Statement * mutate( AsmStmt * asmStmt );
     40        virtual Statement * mutate( IfStmt * ifStmt );
     41        virtual Statement * mutate( WhileStmt * whileStmt );
     42        virtual Statement * mutate( ForStmt * forStmt );
     43        virtual Statement * mutate( SwitchStmt * switchStmt );
     44        virtual Statement * mutate( CaseStmt * caseStmt );
     45        virtual Statement * mutate( BranchStmt * branchStmt );
     46        virtual Statement * mutate( ReturnStmt * returnStmt );
     47        virtual Statement * mutate( ThrowStmt * throwStmt );
     48        virtual Statement * mutate( TryStmt * tryStmt );
     49        virtual Statement * mutate( CatchStmt * catchStmt );
     50        virtual Statement * mutate( FinallyStmt * catchStmt );
     51        virtual Statement * mutate( WaitForStmt * waitforStmt );
     52        virtual NullStmt * mutate( NullStmt * nullStmt );
     53        virtual Statement * mutate( DeclStmt * declStmt );
     54        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt );
    5555
    56         virtual Expression* mutate( ApplicationExpr *applicationExpr );
    57         virtual Expression* mutate( UntypedExpr *untypedExpr );
    58         virtual Expression* mutate( NameExpr *nameExpr );
    59         virtual Expression* mutate( AddressExpr *castExpr );
    60         virtual Expression* mutate( LabelAddressExpr *labAddressExpr );
    61         virtual Expression* mutate( CastExpr *castExpr );
    62         virtual Expression* mutate( VirtualCastExpr *castExpr );
    63         virtual Expression* mutate( UntypedMemberExpr *memberExpr );
    64         virtual Expression* mutate( MemberExpr *memberExpr );
    65         virtual Expression* mutate( VariableExpr *variableExpr );
    66         virtual Expression* mutate( ConstantExpr *constantExpr );
    67         virtual Expression* mutate( SizeofExpr *sizeofExpr );
    68         virtual Expression* mutate( AlignofExpr *alignofExpr );
    69         virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr );
    70         virtual Expression* mutate( OffsetofExpr *offsetofExpr );
    71         virtual Expression* mutate( OffsetPackExpr *offsetPackExpr );
    72         virtual Expression* mutate( AttrExpr *attrExpr );
    73         virtual Expression* mutate( LogicalExpr *logicalExpr );
    74         virtual Expression* mutate( ConditionalExpr *conditionalExpr );
    75         virtual Expression* mutate( CommaExpr *commaExpr );
    76         virtual Expression* mutate( TypeExpr *typeExpr );
    77         virtual Expression* mutate( AsmExpr *asmExpr );
    78         virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
    79         virtual Expression* mutate( ConstructorExpr *ctorExpr );
    80         virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
    81         virtual Expression* mutate( RangeExpr *rangeExpr );
    82         virtual Expression* mutate( UntypedTupleExpr *tupleExpr );
    83         virtual Expression* mutate( TupleExpr *tupleExpr );
    84         virtual Expression* mutate( TupleIndexExpr *tupleExpr );
    85         virtual Expression* mutate( TupleAssignExpr *assignExpr );
    86         virtual Expression* mutate( StmtExpr * stmtExpr );
    87         virtual Expression* mutate( UniqueExpr * uniqueExpr );
    88         virtual Expression* mutate( UntypedInitExpr * initExpr );
    89         virtual Expression* mutate( InitExpr * initExpr );
     56        virtual Expression* mutate( ApplicationExpr * applicationExpr );
     57        virtual Expression* mutate( UntypedExpr * untypedExpr );
     58        virtual Expression* mutate( NameExpr * nameExpr );
     59        virtual Expression* mutate( AddressExpr * castExpr );
     60        virtual Expression* mutate( LabelAddressExpr * labAddressExpr );
     61        virtual Expression* mutate( CastExpr * castExpr );
     62        virtual Expression* mutate( VirtualCastExpr * castExpr );
     63        virtual Expression* mutate( UntypedMemberExpr * memberExpr );
     64        virtual Expression* mutate( MemberExpr * memberExpr );
     65        virtual Expression* mutate( VariableExpr * variableExpr );
     66        virtual Expression* mutate( ConstantExpr * constantExpr );
     67        virtual Expression* mutate( SizeofExpr * sizeofExpr );
     68        virtual Expression* mutate( AlignofExpr * alignofExpr );
     69        virtual Expression* mutate( UntypedOffsetofExpr * offsetofExpr );
     70        virtual Expression* mutate( OffsetofExpr * offsetofExpr );
     71        virtual Expression* mutate( OffsetPackExpr * offsetPackExpr );
     72        virtual Expression* mutate( AttrExpr * attrExpr );
     73        virtual Expression* mutate( LogicalExpr * logicalExpr );
     74        virtual Expression* mutate( ConditionalExpr * conditionalExpr );
     75        virtual Expression* mutate( CommaExpr * commaExpr );
     76        virtual Expression* mutate( TypeExpr * typeExpr );
     77        virtual Expression* mutate( AsmExpr * asmExpr );
     78        virtual Expression* mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
     79        virtual Expression* mutate( ConstructorExpr * ctorExpr );
     80        virtual Expression* mutate( CompoundLiteralExpr * compLitExpr );
     81        virtual Expression* mutate( RangeExpr * rangeExpr );
     82        virtual Expression* mutate( UntypedTupleExpr * tupleExpr );
     83        virtual Expression* mutate( TupleExpr * tupleExpr );
     84        virtual Expression* mutate( TupleIndexExpr * tupleExpr );
     85        virtual Expression* mutate( TupleAssignExpr * assignExpr );
     86        virtual Expression* mutate( StmtExpr  * stmtExpr );
     87        virtual Expression* mutate( UniqueExpr  * uniqueExpr );
     88        virtual Expression* mutate( UntypedInitExpr  * initExpr );
     89        virtual Expression* mutate( InitExpr  * initExpr );
    9090
    91         virtual Type* mutate( VoidType *basicType );
    92         virtual Type* mutate( BasicType *basicType );
    93         virtual Type* mutate( PointerType *pointerType );
    94         virtual Type* mutate( ArrayType *arrayType );
    95         virtual Type* mutate( ReferenceType *refType );
    96         virtual Type* mutate( FunctionType *functionType );
    97         virtual Type* mutate( StructInstType *aggregateUseType );
    98         virtual Type* mutate( UnionInstType *aggregateUseType );
    99         virtual Type* mutate( EnumInstType *aggregateUseType );
    100         virtual Type* mutate( TraitInstType *aggregateUseType );
    101         virtual Type* mutate( TypeInstType *aggregateUseType );
    102         virtual Type* mutate( TupleType *tupleType );
    103         virtual Type* mutate( TypeofType *typeofType );
    104         virtual Type* mutate( AttrType *attrType );
    105         virtual Type* mutate( VarArgsType *varArgsType );
    106         virtual Type* mutate( ZeroType *zeroType );
    107         virtual Type* mutate( OneType *oneType );
     91        virtual Type * mutate( VoidType * basicType );
     92        virtual Type * mutate( BasicType * basicType );
     93        virtual Type * mutate( PointerType * pointerType );
     94        virtual Type * mutate( ArrayType * arrayType );
     95        virtual Type * mutate( ReferenceType * refType );
     96        virtual Type * mutate( FunctionType * functionType );
     97        virtual Type * mutate( StructInstType * aggregateUseType );
     98        virtual Type * mutate( UnionInstType * aggregateUseType );
     99        virtual Type * mutate( EnumInstType * aggregateUseType );
     100        virtual Type * mutate( TraitInstType * aggregateUseType );
     101        virtual Type * mutate( TypeInstType * aggregateUseType );
     102        virtual Type * mutate( TupleType * tupleType );
     103        virtual Type * mutate( TypeofType * typeofType );
     104        virtual Type * mutate( AttrType * attrType );
     105        virtual Type * mutate( VarArgsType * varArgsType );
     106        virtual Type * mutate( ZeroType * zeroType );
     107        virtual Type * mutate( OneType * oneType );
    108108
    109         virtual Designation* mutate( Designation *designation );
    110         virtual Initializer* mutate( SingleInit *singleInit );
    111         virtual Initializer* mutate( ListInit *listInit );
    112         virtual Initializer* mutate( ConstructorInit *ctorInit );
     109        virtual Designation * mutate( Designation * designation );
     110        virtual Initializer * mutate( SingleInit * singleInit );
     111        virtual Initializer * mutate( ListInit * listInit );
     112        virtual Initializer * mutate( ConstructorInit * ctorInit );
    113113
    114         virtual Subrange *mutate( Subrange *subrange );
     114        virtual Subrange * mutate( Subrange * subrange );
    115115
    116         virtual Constant *mutate( Constant *constant );
     116        virtual Constant * mutate( Constant * constant );
     117
     118        virtual Attribute * mutate( Attribute * attribute );
    117119  private:
    118         virtual Declaration* handleAggregateDecl(AggregateDecl *aggregateDecl );
    119         virtual Declaration* handleNamedTypeDecl(NamedTypeDecl *typeDecl );
    120         virtual Type* handleReferenceToType(ReferenceToType *aggregateUseType );
     120        virtual Declaration * handleAggregateDecl(AggregateDecl * aggregateDecl );
     121        virtual Declaration * handleNamedTypeDecl(NamedTypeDecl * typeDecl );
     122        virtual Type * handleReferenceToType(ReferenceToType * aggregateUseType );
    121123};
    122124

  • src/SynTree/Statement.h

    r12914e9 rea156ae  
    4343        const std::list<Label> & get_labels() const { return labels; }
    4444
    45         virtual Statement *clone() const = 0;
     45        virtual Statement *clone() const override = 0;
    4646        virtual void accept( Visitor &v ) override = 0;
    47         virtual Statement *acceptMutator( Mutator &m ) = 0;
     47        virtual Statement *acceptMutator( Mutator &m ) override = 0;
    4848        virtual void print( std::ostream &os, int indent = 0 ) const override;
    4949};

  • src/SynTree/VarExprReplacer.h

    r12914e9 rea156ae  
    2929private:
    3030        const DeclMap & declMap;
    31   bool debug;
     31        bool debug;
    3232public:
    3333        VarExprReplacer( const DeclMap & declMap, bool debug = false );
    … …  
    3535        // replace variable with new node from decl map
    3636        virtual void visit( VariableExpr * varExpr );
     37
     38        static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) {
     39                VarExprReplacer replacer( declMap, debug );
     40                maybeAccept( node, replacer );
     41        }
    3742};
    3843

  • src/SynTree/Visitor.cc

    r12914e9 rea156ae  
    1717#include <list>           // for list
    1818
     19#include "Attribute.h"    // for Attribute
    1920#include "Constant.h"     // for Constant
    2021#include "Declaration.h"  // for DeclarationWithType, ObjectDecl, Declaration
    … …  
    3536        maybeAccept( objectDecl->get_init(), *this );
    3637        maybeAccept( objectDecl->get_bitfieldWidth(), *this );
     38        acceptAll( objectDecl->attributes, *this );
    3739}
    3840
    … …  
    4042        maybeAccept( functionDecl->get_functionType(), *this );
    4143        maybeAccept( functionDecl->get_statements(), *this );
     44        acceptAll( functionDecl->attributes, *this );
    4245}
    4346
    … …  
    487490
    488491
    489 void Visitor::visit( __attribute__((unused)) Subrange *subrange ) {}
    490 
    491 
    492 void Visitor::visit( __attribute__((unused)) Constant *constant ) {}
     492void Visitor::visit( Subrange * ) {}
     493
     494
     495void Visitor::visit( Constant * ) {}
     496
     497void Visitor::visit( Attribute * attribute ) {
     498        acceptAll( attribute->parameters, *this );
     499}
     500
    493501// Local Variables: //
    494502// tab-width: 4 //

  • src/SynTree/Visitor.h

    r12914e9 rea156ae  
    2727        // of the given syntax node, but performs no other action.
    2828
    29         virtual void visit( ObjectDecl *objectDecl );
    30         virtual void visit( FunctionDecl *functionDecl );
    31         virtual void visit( StructDecl *aggregateDecl );
    32         virtual void visit( UnionDecl *aggregateDecl );
    33         virtual void visit( EnumDecl *aggregateDecl );
    34         virtual void visit( TraitDecl *aggregateDecl );
    35         virtual void visit( TypeDecl *typeDecl );
    36         virtual void visit( TypedefDecl *typeDecl );
    37         virtual void visit( AsmDecl *asmDecl );
     29        virtual void visit( ObjectDecl * objectDecl );
     30        virtual void visit( FunctionDecl * functionDecl );
     31        virtual void visit( StructDecl * aggregateDecl );
     32        virtual void visit( UnionDecl * aggregateDecl );
     33        virtual void visit( EnumDecl * aggregateDecl );
     34        virtual void visit( TraitDecl * aggregateDecl );
     35        virtual void visit( TypeDecl * typeDecl );
     36        virtual void visit( TypedefDecl * typeDecl );
     37        virtual void visit( AsmDecl * asmDecl );
    3838
    39         virtual void visit( CompoundStmt *compoundStmt );
    40         virtual void visit( ExprStmt *exprStmt );
    41         virtual void visit( AsmStmt *asmStmt );
    42         virtual void visit( IfStmt *ifStmt );
    43         virtual void visit( WhileStmt *whileStmt );
    44         virtual void visit( ForStmt *forStmt );
    45         virtual void visit( SwitchStmt *switchStmt );
    46         virtual void visit( CaseStmt *caseStmt );
    47         virtual void visit( BranchStmt *branchStmt );
    48         virtual void visit( ReturnStmt *returnStmt );
    49         virtual void visit( ThrowStmt *throwStmt );
    50         virtual void visit( TryStmt *tryStmt );
    51         virtual void visit( CatchStmt *catchStmt );
    52         virtual void visit( FinallyStmt *finallyStmt );
    53         virtual void visit( WaitForStmt *waitforStmt );
    54         virtual void visit( NullStmt *nullStmt );
    55         virtual void visit( DeclStmt *declStmt );
    56         virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt );
     39        virtual void visit( CompoundStmt * compoundStmt );
     40        virtual void visit( ExprStmt * exprStmt );
     41        virtual void visit( AsmStmt * asmStmt );
     42        virtual void visit( IfStmt * ifStmt );
     43        virtual void visit( WhileStmt * whileStmt );
     44        virtual void visit( ForStmt * forStmt );
     45        virtual void visit( SwitchStmt * switchStmt );
     46        virtual void visit( CaseStmt * caseStmt );
     47        virtual void visit( BranchStmt * branchStmt );
     48        virtual void visit( ReturnStmt * returnStmt );
     49        virtual void visit( ThrowStmt * throwStmt );
     50        virtual void visit( TryStmt * tryStmt );
     51        virtual void visit( CatchStmt * catchStmt );
     52        virtual void visit( FinallyStmt * finallyStmt );
     53        virtual void visit( WaitForStmt * waitforStmt );
     54        virtual void visit( NullStmt * nullStmt );
     55        virtual void visit( DeclStmt * declStmt );
     56        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
    5757
    58         virtual void visit( ApplicationExpr *applicationExpr );
    59         virtual void visit( UntypedExpr *untypedExpr );
    60         virtual void visit( NameExpr *nameExpr );
    61         virtual void visit( CastExpr *castExpr );
    62         virtual void visit( VirtualCastExpr *castExpr );
    63         virtual void visit( AddressExpr *addressExpr );
    64         virtual void visit( LabelAddressExpr *labAddressExpr );
    65         virtual void visit( UntypedMemberExpr *memberExpr );
    66         virtual void visit( MemberExpr *memberExpr );
    67         virtual void visit( VariableExpr *variableExpr );
    68         virtual void visit( ConstantExpr *constantExpr );
    69         virtual void visit( SizeofExpr *sizeofExpr );
    70         virtual void visit( AlignofExpr *alignofExpr );
    71         virtual void visit( UntypedOffsetofExpr *offsetofExpr );
    72         virtual void visit( OffsetofExpr *offsetofExpr );
    73         virtual void visit( OffsetPackExpr *offsetPackExpr );
    74         virtual void visit( AttrExpr *attrExpr );
    75         virtual void visit( LogicalExpr *logicalExpr );
    76         virtual void visit( ConditionalExpr *conditionalExpr );
    77         virtual void visit( CommaExpr *commaExpr );
    78         virtual void visit( TypeExpr *typeExpr );
    79         virtual void visit( AsmExpr *asmExpr );
    80         virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
    81         virtual void visit( ConstructorExpr * ctorExpr );
    82         virtual void visit( CompoundLiteralExpr *compLitExpr );
    83         virtual void visit( RangeExpr *rangeExpr );
    84         virtual void visit( UntypedTupleExpr *tupleExpr );
    85         virtual void visit( TupleExpr *tupleExpr );
    86         virtual void visit( TupleIndexExpr *tupleExpr );
    87         virtual void visit( TupleAssignExpr *assignExpr );
    88         virtual void visit( StmtExpr * stmtExpr );
    89         virtual void visit( UniqueExpr * uniqueExpr );
    90         virtual void visit( UntypedInitExpr * initExpr );
    91         virtual void visit( InitExpr * initExpr );
     58        virtual void visit( ApplicationExpr * applicationExpr );
     59        virtual void visit( UntypedExpr * untypedExpr );
     60        virtual void visit( NameExpr * nameExpr );
     61        virtual void visit( CastExpr * castExpr );
     62        virtual void visit( VirtualCastExpr * castExpr );
     63        virtual void visit( AddressExpr * addressExpr );
     64        virtual void visit( LabelAddressExpr * labAddressExpr );
     65        virtual void visit( UntypedMemberExpr * memberExpr );
     66        virtual void visit( MemberExpr * memberExpr );
     67        virtual void visit( VariableExpr * variableExpr );
     68        virtual void visit( ConstantExpr * constantExpr );
     69        virtual void visit( SizeofExpr * sizeofExpr );
     70        virtual void visit( AlignofExpr * alignofExpr );
     71        virtual void visit( UntypedOffsetofExpr * offsetofExpr );
     72        virtual void visit( OffsetofExpr * offsetofExpr );
     73        virtual void visit( OffsetPackExpr * offsetPackExpr );
     74        virtual void visit( AttrExpr * attrExpr );
     75        virtual void visit( LogicalExpr * logicalExpr );
     76        virtual void visit( ConditionalExpr * conditionalExpr );
     77        virtual void visit( CommaExpr * commaExpr );
     78        virtual void visit( TypeExpr * typeExpr );
     79        virtual void visit( AsmExpr * asmExpr );
     80        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
     81        virtual void visit( ConstructorExpr *  ctorExpr );
     82        virtual void visit( CompoundLiteralExpr * compLitExpr );
     83        virtual void visit( RangeExpr * rangeExpr );
     84        virtual void visit( UntypedTupleExpr * tupleExpr );
     85        virtual void visit( TupleExpr * tupleExpr );
     86        virtual void visit( TupleIndexExpr * tupleExpr );
     87        virtual void visit( TupleAssignExpr * assignExpr );
     88        virtual void visit( StmtExpr *  stmtExpr );
     89        virtual void visit( UniqueExpr *  uniqueExpr );
     90        virtual void visit( UntypedInitExpr *  initExpr );
     91        virtual void visit( InitExpr *  initExpr );
    9292
    93         virtual void visit( VoidType *basicType );
    94         virtual void visit( BasicType *basicType );
    95         virtual void visit( PointerType *pointerType );
    96         virtual void visit( ArrayType *arrayType );
    97         virtual void visit( ReferenceType *refType );
    98         virtual void visit( FunctionType *functionType );
    99         virtual void visit( StructInstType *aggregateUseType );
    100         virtual void visit( UnionInstType *aggregateUseType );
    101         virtual void visit( EnumInstType *aggregateUseType );
    102         virtual void visit( TraitInstType *aggregateUseType );
    103         virtual void visit( TypeInstType *aggregateUseType );
    104         virtual void visit( TupleType *tupleType );
    105         virtual void visit( TypeofType *typeofType );
    106         virtual void visit( AttrType *attrType );
    107         virtual void visit( VarArgsType *varArgsType );
    108         virtual void visit( ZeroType *zeroType );
    109         virtual void visit( OneType *oneType );
     93        virtual void visit( VoidType * basicType );
     94        virtual void visit( BasicType * basicType );
     95        virtual void visit( PointerType * pointerType );
     96        virtual void visit( ArrayType * arrayType );
     97        virtual void visit( ReferenceType * refType );
     98        virtual void visit( FunctionType * functionType );
     99        virtual void visit( StructInstType * aggregateUseType );
     100        virtual void visit( UnionInstType * aggregateUseType );
     101        virtual void visit( EnumInstType * aggregateUseType );
     102        virtual void visit( TraitInstType * aggregateUseType );
     103        virtual void visit( TypeInstType * aggregateUseType );
     104        virtual void visit( TupleType * tupleType );
     105        virtual void visit( TypeofType * typeofType );
     106        virtual void visit( AttrType * attrType );
     107        virtual void visit( VarArgsType * varArgsType );
     108        virtual void visit( ZeroType * zeroType );
     109        virtual void visit( OneType * oneType );
    110110
    111         virtual void visit( Designation *designation );
    112         virtual void visit( SingleInit *singleInit );
    113         virtual void visit( ListInit *listInit );
    114         virtual void visit( ConstructorInit *ctorInit );
     111        virtual void visit( Designation * designation );
     112        virtual void visit( SingleInit * singleInit );
     113        virtual void visit( ListInit * listInit );
     114        virtual void visit( ConstructorInit * ctorInit );
    115115
    116         virtual void visit( Subrange *subrange );
     116        virtual void visit( Subrange * subrange );
    117117
    118         virtual void visit( Constant *constant );
     118        virtual void visit( Constant * constant );
     119
     120        virtual void visit( Attribute * attribute );
    119121  private:
    120122        virtual void handleAggregateDecl( AggregateDecl *aggregateDecl );
Note: See TracChangeset for help on using the changeset viewer.