Changeset d67cdb7 for src/SynTree


Ignore:
Timestamp:
Sep 26, 2017, 11:27:38 PM (8 years ago)
Author:
Peter A. Buhr <pabuhr@…>
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:
5dc26f5
Parents:
201aeb9
Message:

merge

Location:
src/SynTree
Files:
2 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/BaseSyntaxNode.h

    r201aeb9 rd67cdb7  
    2626
    2727        virtual void accept( Visitor & v ) = 0;
    28   virtual void print( std::ostream & os, int indent = 0 ) const = 0;
     28        virtual void print( std::ostream & os, int indent = 0 ) const = 0;
    2929};
     30
     31std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node );
    3032
    3133// Local Variables: //

  • src/SynTree/CompoundStmt.cc

    r201aeb9 rd67cdb7  
    2929
    3030CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
     31}
     32
     33CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
    3134}
    3235

  • src/SynTree/Constant.cc

    r201aeb9 rd67cdb7  
    3232Constant Constant::from_bool( bool b ) {
    3333        return Constant( new BasicType( Type::Qualifiers(), BasicType::Bool ), b ? "1" : "0" , (unsigned long long int)b );
     34}
     35
     36Constant Constant::from_char( char c ) {
     37        return Constant( new BasicType( Type::Qualifiers(), BasicType::Char ), std::to_string( c ), (unsigned long long int)c );
    3438}
    3539

  • src/SynTree/Constant.h

    r201aeb9 rd67cdb7  
    4040        /// generates a boolean constant of the given bool
    4141        static Constant from_bool( bool b );
     42        /// generates a char constant of the given char
     43        static Constant from_char( char c );
    4244        /// generates an integer constant of the given int
    4345        static Constant from_int( int i );

  • src/SynTree/Declaration.cc

    r201aeb9 rd67cdb7  
    5959}
    6060
    61 std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
    62         if ( decl ){
    63                 decl->print( out );
    64         } else {
    65                 out << "nullptr";
    66         }
    67         return out;
    68 }
    69 
    7061
    7162AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {

  • src/SynTree/Declaration.h

    r201aeb9 rd67cdb7  
    6262        void fixUniqueId( void );
    6363        virtual Declaration *clone() const = 0;
    64         virtual void accept( Visitor &v ) = 0;
     64        virtual void accept( Visitor &v ) override = 0;
    6565        virtual Declaration *acceptMutator( Mutator &m ) = 0;
    66         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
     66        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
    6767        virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
    6868
    … …  
    106106        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
    107107
    108         virtual DeclarationWithType *clone() const = 0;
    109         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
     108        virtual DeclarationWithType *clone() const override = 0;
     109        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
    110110
    111111        virtual Type * get_type() const = 0;
    … …  
    128128        virtual ~ObjectDecl();
    129129
    130         virtual Type * get_type() const { return type; }
    131         virtual void set_type(Type *newType) { type = newType; }
     130        virtual Type * get_type() const override { return type; }
     131        virtual void set_type(Type *newType) override { type = newType; }
    132132
    133133        Initializer *get_init() const { return init; }
    … …  
    139139        static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
    140140
    141         virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
    142         virtual void accept( Visitor &v ) { v.visit( this ); }
    143         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    144         virtual void print( std::ostream &os, int indent = 0 ) const;
    145         virtual void printShort( std::ostream &os, int indent = 0 ) const;
     141        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
     142        virtual void accept( Visitor &v ) override { v.visit( this ); }
     143        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     144        virtual void print( std::ostream &os, int indent = 0 ) const override;
     145        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    146146};
    147147
    … …  
    157157        virtual ~FunctionDecl();
    158158
    159         Type * get_type() const { return type; }
    160         virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
     159        virtual Type * get_type() const override { return type; }
     160        virtual void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
    161161
    162162        FunctionType * get_functionType() const { return type; }
    … …  
    165165        void set_statements( CompoundStmt *newValue ) { statements = newValue; }
    166166
    167         virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
    168         virtual void accept( Visitor &v ) { v.visit( this ); }
    169         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    170         virtual void print( std::ostream &os, int indent = 0 ) const;
    171         virtual void printShort( std::ostream &os, int indent = 0 ) const;
     167        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
     168        virtual void accept( Visitor &v ) override { v.visit( this ); }
     169        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     170        virtual void print( std::ostream &os, int indent = 0 ) const override;
     171        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    172172};
    173173
    … …  
    190190        virtual std::string typeString() const = 0;
    191191
    192         virtual NamedTypeDecl *clone() const = 0;
    193         virtual void print( std::ostream &os, int indent = 0 ) const;
    194         virtual void printShort( std::ostream &os, int indent = 0 ) const;
     192        virtual NamedTypeDecl *clone() const override = 0;
     193        virtual void print( std::ostream &os, int indent = 0 ) const override;
     194        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    195195};
    196196
    … …  
    227227        TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
    228228
    229         virtual std::string typeString() const;
     229        virtual std::string typeString() const override;
    230230        virtual std::string genTypeString() const;
    231231
    232         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
    233         virtual void accept( Visitor &v ) { v.visit( this ); }
    234         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    235         virtual void print( std::ostream &os, int indent = 0 ) const;
     232        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
     233        virtual void accept( Visitor &v ) override { v.visit( this ); }
     234        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     235        virtual void print( std::ostream &os, int indent = 0 ) const override;
    236236
    237237  private:
    … …  
    245245        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
    246246
    247         virtual std::string typeString() const;
    248 
    249         virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
    250         virtual void accept( Visitor &v ) { v.visit( this ); }
    251         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     247        virtual std::string typeString() const override;
     248
     249        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
     250        virtual void accept( Visitor &v ) override { v.visit( this ); }
     251        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    252252  private:
    253253};
    … …  
    274274        AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
    275275
    276         virtual void print( std::ostream &os, int indent = 0 ) const;
    277         virtual void printShort( std::ostream &os, int indent = 0 ) const;
     276        virtual void print( std::ostream &os, int indent = 0 ) const override;
     277        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
    278278  protected:
    279279        virtual std::string typeString() const = 0;
    … …  
    290290        bool is_thread() { return kind == DeclarationNode::Thread; }
    291291
    292         virtual StructDecl *clone() const { return new StructDecl( *this ); }
    293         virtual void accept( Visitor &v ) { v.visit( this ); }
    294         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     292        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
     293        virtual void accept( Visitor &v ) override { v.visit( this ); }
     294        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    295295  private:
    296296        DeclarationNode::Aggregate kind;
    297         virtual std::string typeString() const;
     297        virtual std::string typeString() const override;
    298298};
    299299
    … …  
    304304        UnionDecl( const UnionDecl &other ) : Parent( other ) {}
    305305
    306         virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
    307         virtual void accept( Visitor &v ) { v.visit( this ); }
    308         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    309   private:
    310         virtual std::string typeString() const;
     306        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
     307        virtual void accept( Visitor &v ) override { v.visit( this ); }
     308        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     309  private:
     310        virtual std::string typeString() const override;
    311311};
    312312
    … …  
    317317        EnumDecl( const EnumDecl &other ) : Parent( other ) {}
    318318
    319         virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
    320         virtual void accept( Visitor &v ) { v.visit( this ); }
    321         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    322   private:
    323         virtual std::string typeString() const;
     319        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
     320        virtual void accept( Visitor &v ) override { v.visit( this ); }
     321        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     322  private:
     323        virtual std::string typeString() const override;
    324324};
    325325
    … …  
    332332        TraitDecl( const TraitDecl &other ) : Parent( other ) {}
    333333
    334         virtual TraitDecl *clone() const { return new TraitDecl( *this ); }
    335         virtual void accept( Visitor &v ) { v.visit( this ); }
    336         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    337   private:
    338         virtual std::string typeString() const;
     334        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
     335        virtual void accept( Visitor &v ) override { v.visit( this ); }
     336        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     337  private:
     338        virtual std::string typeString() const override;
    339339};
    340340
    … …  
    350350        void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
    351351
    352         virtual AsmDecl *clone() const { return new AsmDecl( *this ); }
    353         virtual void accept( Visitor &v ) { v.visit( this ); }
    354         virtual AsmDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    355         virtual void print( std::ostream &os, int indent = 0 ) const;
    356         virtual void printShort( std::ostream &os, int indent = 0 ) const;
    357 };
    358 
    359 std::ostream & operator<<( std::ostream & out, const Declaration * decl );
     352        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
     353        virtual void accept( Visitor &v ) override { v.visit( this ); }
     354        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     355        virtual void print( std::ostream &os, int indent = 0 ) const override;
     356        virtual void printShort( std::ostream &os, int indent = 0 ) const override;
     357};
     358
    360359std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
    361360

  • src/SynTree/Expression.cc

    r201aeb9 rd67cdb7  
    741741}
    742742
    743 
    744 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
    745         if ( expr ) {
    746                 expr->print( out );
    747         } else {
    748                 out << "nullptr";
    749         }
    750         return out;
    751 }
    752 
    753743// Local Variables: //
    754744// tab-width: 4 //

  • src/SynTree/Expression.h

    r201aeb9 rd67cdb7  
    821821};
    822822
    823 
    824 std::ostream & operator<<( std::ostream & out, const Expression * expr );
    825 
    826823// Local Variables: //
    827824// tab-width: 4 //

  • src/SynTree/Initializer.cc

    r201aeb9 rd67cdb7  
    137137}
    138138
    139 std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
    140         if ( init ) {
    141                 init->print( out );
    142         } else {
    143                 out << "nullptr";
    144         }
    145         return out;
    146 }
    147 
    148 std::ostream & operator<<( std::ostream & out, const Designation * des ) {
    149         if ( des ) {
    150                 des->print( out );
    151         } else {
    152                 out << "nullptr";
    153         }
    154         return out;
    155 }
    156 
    157139// Local Variables: //
    158140// tab-width: 4 //

  • src/SynTree/Initializer.h

    r201aeb9 rd67cdb7  
    3838
    3939        virtual Designation * clone() const { return new Designation( *this ); };
    40         virtual void accept( Visitor &v ) { v.visit( this ); }
     40        virtual void accept( Visitor &v ) override { v.visit( this ); }
    4141        virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
    42         virtual void print( std::ostream &os, int indent = 0 ) const;
     42        virtual void print( std::ostream &os, int indent = 0 ) const override;
    4343};
    4444
    … …  
    5555
    5656        virtual Initializer *clone() const = 0;
    57         virtual void accept( Visitor &v ) = 0;
     57        virtual void accept( Visitor &v ) override = 0;
    5858        virtual Initializer *acceptMutator( Mutator &m ) = 0;
    59         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
     59        virtual void print( std::ostream &os, int indent = 0 ) const override = 0;
    6060  private:
    6161        bool maybeConstructed;
    … …  
    7575        void set_value( Expression *newValue ) { value = newValue; }
    7676
    77         virtual SingleInit *clone() const { return new SingleInit( *this); }
    78         virtual void accept( Visitor &v ) { v.visit( this ); }
    79         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    80         virtual void print( std::ostream &os, int indent = 0 ) const;
     77        virtual SingleInit *clone() const override { return new SingleInit( *this); }
     78        virtual void accept( Visitor &v ) override { v.visit( this ); }
     79        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     80        virtual void print( std::ostream &os, int indent = 0 ) const override;
    8181};
    8282
    … …  
    103103        const_iterator end() const { return initializers.end(); }
    104104
    105         virtual ListInit *clone() const { return new ListInit( *this ); }
    106         virtual void accept( Visitor &v ) { v.visit( this ); }
    107         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    108         virtual void print( std::ostream &os, int indent = 0 ) const;
     105        virtual ListInit *clone() const override { return new ListInit( *this ); }
     106        virtual void accept( Visitor &v ) override { v.visit( this ); }
     107        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     108        virtual void print( std::ostream &os, int indent = 0 ) const override;
    109109};
    110110
    … …  
    129129        Initializer * get_init() const { return init; }
    130130
    131         ConstructorInit *clone() const { return new ConstructorInit( *this ); }
    132         virtual void accept( Visitor &v ) { v.visit( this ); }
    133         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    134         virtual void print( std::ostream &os, int indent = 0 ) const;
     131        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
     132        virtual void accept( Visitor &v ) override { v.visit( this ); }
     133        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     134        virtual void print( std::ostream &os, int indent = 0 ) const override;
    135135
    136136  private:
    … …  
    140140};
    141141
    142 std::ostream & operator<<( std::ostream & out, const Initializer * init );
    143 std::ostream & operator<<( std::ostream & out, const Designation * des );
    144 
    145142// Local Variables: //
    146143// tab-width: 4 //

  • src/SynTree/Statement.cc

    r201aeb9 rd67cdb7  
    168168}
    169169
    170 SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, std::list<Statement *> &statements ):
     170SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
    171171        Statement( labels ), condition( condition ), statements( statements ) {
    172172}
    … …  
    196196}
    197197
    198 CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
     198CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
    199199        Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
    200200        if ( isDefault() && condition != 0 )
    … …  
    497497}
    498498
    499 std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
    500         if ( statement ) {
    501                 statement->print( out );
    502         } else {
    503                 out << "nullptr";
    504         }
    505         return out;
    506 }
    507 
    508499// Local Variables: //
    509500// tab-width: 4 //

  • src/SynTree/Statement.h

    r201aeb9 rd67cdb7  
    4444
    4545        virtual Statement *clone() const = 0;
    46         virtual void accept( Visitor &v ) = 0;
     46        virtual void accept( Visitor &v ) override = 0;
    4747        virtual Statement *acceptMutator( Mutator &m ) = 0;
    48         virtual void print( std::ostream &os, int indent = 0 ) const;
     48        virtual void print( std::ostream &os, int indent = 0 ) const override;
    4949};
    5050
    … …  
    5454
    5555        CompoundStmt( std::list<Label> labels );
     56        CompoundStmt( std::list<Statement *> stmts );
    5657        CompoundStmt( const CompoundStmt &other );
    5758        virtual ~CompoundStmt();
    … …  
    6162        void push_front( Statement * stmt ) { kids.push_front( stmt ); }
    6263
    63         virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
    64         virtual void accept( Visitor &v ) { v.visit( this ); }
    65         virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    66         virtual void print( std::ostream &os, int indent = 0 ) const;
     64        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
     65        virtual void accept( Visitor &v ) override { v.visit( this ); }
     66        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     67        virtual void print( std::ostream &os, int indent = 0 ) const override;
    6768};
    6869
    … …  
    7273        NullStmt( std::list<Label> labels );
    7374
    74         virtual NullStmt *clone() const { return new NullStmt( *this ); }
    75         virtual void accept( Visitor &v ) { v.visit( this ); }
    76         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    77         virtual void print( std::ostream &os, int indent = 0 ) const;
     75        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
     76        virtual void accept( Visitor &v ) override { v.visit( this ); }
     77        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     78        virtual void print( std::ostream &os, int indent = 0 ) const override;
    7879};
    7980
    … …  
    8990        void set_expr( Expression *newValue ) { expr = newValue; }
    9091
    91         virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
    92         virtual void accept( Visitor &v ) { v.visit( this ); }
    93         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    94         virtual void print( std::ostream &os, int indent = 0 ) const;
     92        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
     93        virtual void accept( Visitor &v ) override { v.visit( this ); }
     94        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     95        virtual void print( std::ostream &os, int indent = 0 ) const override;
    9596};
    9697
    … …  
    146147        void set_elsePart( Statement *newValue ) { elsePart = newValue; }
    147148
    148         virtual IfStmt *clone() const { return new IfStmt( *this ); }
    149         virtual void accept( Visitor &v ) { v.visit( this ); }
    150         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    151         virtual void print( std::ostream &os, int indent = 0 ) const;
     149        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
     150        virtual void accept( Visitor &v ) override { v.visit( this ); }
     151        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     152        virtual void print( std::ostream &os, int indent = 0 ) const override;
    152153};
    153154
    … …  
    157158        std::list<Statement *> statements;
    158159
    159         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
     160        SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
    160161        SwitchStmt( const SwitchStmt &other );
    161162        virtual ~SwitchStmt();
    … …  
    166167        std::list<Statement *> & get_statements() { return statements; }
    167168
    168         virtual void accept( Visitor &v ) { v.visit( this ); }
    169         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    170 
    171         virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
    172         virtual void print( std::ostream &os, int indent = 0 ) const;
     169        virtual void accept( Visitor &v ) override { v.visit( this ); }
     170        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     171
     172        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
     173        virtual void print( std::ostream &os, int indent = 0 ) const override;
    173174
    174175};
    … …  
    179180        std::list<Statement *> stmts;
    180181
    181         CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
     182        CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
    182183        CaseStmt( const CaseStmt &other );
    183184        virtual ~CaseStmt();
    … …  
    194195        void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
    195196
    196         virtual void accept( Visitor &v ) { v.visit( this ); }
    197         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    198 
    199         virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
    200         virtual void print( std::ostream &os, int indent = 0 ) const;
     197        virtual void accept( Visitor &v ) override { v.visit( this ); }
     198        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     199
     200        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
     201        virtual void print( std::ostream &os, int indent = 0 ) const override;
    201202  private:
    202203        bool _isDefault;
    … …  
    221222        void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
    222223
    223         virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
    224         virtual void accept( Visitor &v ) { v.visit( this ); }
    225         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    226         virtual void print( std::ostream &os, int indent = 0 ) const;
     224        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
     225        virtual void accept( Visitor &v ) override { v.visit( this ); }
     226        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     227        virtual void print( std::ostream &os, int indent = 0 ) const override;
    227228};
    228229
    … …  
    247248        void set_body( Statement *newValue ) { body = newValue; }
    248249
    249         virtual ForStmt *clone() const { return new ForStmt( *this ); }
    250         virtual void accept( Visitor &v ) { v.visit( this ); }
    251         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    252         virtual void print( std::ostream &os, int indent = 0 ) const;
     250        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
     251        virtual void accept( Visitor &v ) override { v.visit( this ); }
     252        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     253        virtual void print( std::ostream &os, int indent = 0 ) const override;
    253254};
    254255
    … …  
    276277        const char *get_typename() { return brType[ type ]; }
    277278
    278         virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
    279         virtual void accept( Visitor &v ) { v.visit( this ); }
    280         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    281         virtual void print( std::ostream &os, int indent = 0 ) const;
     279        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
     280        virtual void accept( Visitor &v ) override { v.visit( this ); }
     281        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     282        virtual void print( std::ostream &os, int indent = 0 ) const override;
    282283  private:
    283284        static const char *brType[];
    … …  
    295296        void set_expr( Expression *newValue ) { expr = newValue; }
    296297
    297         virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
    298         virtual void accept( Visitor &v ) { v.visit( this ); }
    299         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    300         virtual void print( std::ostream &os, int indent = 0 ) const;
     298        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
     299        virtual void accept( Visitor &v ) override { v.visit( this ); }
     300        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     301        virtual void print( std::ostream &os, int indent = 0 ) const override;
    301302};
    302303
    … …  
    319320        void set_target( Expression * newTarget ) { target = newTarget; }
    320321
    321         virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
    322         virtual void accept( Visitor &v ) { v.visit( this ); }
    323         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    324         virtual void print( std::ostream &os, int indent = 0 ) const;
     322        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
     323        virtual void accept( Visitor &v ) override { v.visit( this ); }
     324        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     325        virtual void print( std::ostream &os, int indent = 0 ) const override;
    325326};
    326327
    … …  
    342343        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
    343344
    344         virtual TryStmt *clone() const { return new TryStmt( *this ); }
    345         virtual void accept( Visitor &v ) { v.visit( this ); }
    346         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    347         virtual void print( std::ostream &os, int indent = 0 ) const;
     345        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
     346        virtual void accept( Visitor &v ) override { v.visit( this ); }
     347        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     348        virtual void print( std::ostream &os, int indent = 0 ) const override;
    348349};
    349350
    … …  
    370371        void set_body( Statement *newValue ) { body = newValue; }
    371372
    372         virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
    373         virtual void accept( Visitor &v ) { v.visit( this ); }
    374         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    375         virtual void print( std::ostream &os, int indent = 0 ) const;
     373        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
     374        virtual void accept( Visitor &v ) override { v.visit( this ); }
     375        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     376        virtual void print( std::ostream &os, int indent = 0 ) const override;
    376377};
    377378
    … …  
    387388        void set_block( CompoundStmt *newValue ) { block = newValue; }
    388389
    389         virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
    390         virtual void accept( Visitor &v ) { v.visit( this ); }
    391         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    392         virtual void print( std::ostream &os, int indent = 0 ) const;
     390        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
     391        virtual void accept( Visitor &v ) override { v.visit( this ); }
     392        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     393        virtual void print( std::ostream &os, int indent = 0 ) const override;
    393394};
    394395
    … …  
    424425        } orelse;
    425426
    426         virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
    427         virtual void accept( Visitor &v ) { v.visit( this ); }
    428         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    429         virtual void print( std::ostream &os, int indent = 0 ) const;
     427        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
     428        virtual void accept( Visitor &v ) override { v.visit( this ); }
     429        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     430        virtual void print( std::ostream &os, int indent = 0 ) const override;
    430431
    431432};
    … …  
    444445        void set_decl( Declaration *newValue ) { decl = newValue; }
    445446
    446         virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
    447         virtual void accept( Visitor &v ) { v.visit( this ); }
    448         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    449         virtual void print( std::ostream &os, int indent = 0 ) const;
     447        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
     448        virtual void accept( Visitor &v ) override { v.visit( this ); }
     449        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     450        virtual void print( std::ostream &os, int indent = 0 ) const override;
    450451};
    451452
    … …  
    466467        void set_callStmt( Statement * newValue ) { callStmt = newValue; }
    467468
    468         virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
    469         virtual void accept( Visitor &v ) { v.visit( this ); }
    470         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    471         virtual void print( std::ostream &os, int indent = 0 ) const;
    472 };
    473 
    474 
    475 std::ostream & operator<<( std::ostream & out, const Statement * statement );
     469        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
     470        virtual void accept( Visitor &v ) override { v.visit( this ); }
     471        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     472        virtual void print( std::ostream &os, int indent = 0 ) const override;
     473};
    476474
    477475// Local Variables: //

  • src/SynTree/Type.cc

    r201aeb9 rd67cdb7  
    101101const Type::Qualifiers noQualifiers;
    102102
    103 std::ostream & operator<<( std::ostream & out, const Type * type ) {
    104         if ( type ) {
    105                 type->print( out );
    106         } else {
    107                 out << "nullptr";
    108         } // if
    109         return out;
    110 }
    111 
    112103// Local Variables: //
    113104// tab-width: 4 //

  • src/SynTree/Type.h

    r201aeb9 rd67cdb7  
    192192        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    193193
    194         virtual unsigned size() const { return 0; };
    195         virtual bool isComplete() const { return false; }
    196 
    197         virtual VoidType *clone() const { return new VoidType( *this ); }
    198         virtual void accept( Visitor & v ) { v.visit( this ); }
    199         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    200         virtual void print( std::ostream & os, int indent = 0 ) const;
     194        virtual unsigned size() const override { return 0; };
     195        virtual bool isComplete() const override { return false; }
     196
     197        virtual VoidType *clone() const override { return new VoidType( *this ); }
     198        virtual void accept( Visitor & v ) override { v.visit( this ); }
     199        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     200        virtual void print( std::ostream & os, int indent = 0 ) const override;
    201201};
    202202
    … …  
    237237        void set_kind( Kind newValue ) { kind = newValue; }
    238238
    239         virtual BasicType *clone() const { return new BasicType( *this ); }
    240         virtual void accept( Visitor & v ) { v.visit( this ); }
    241         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    242         virtual void print( std::ostream & os, int indent = 0 ) const;
     239        virtual BasicType *clone() const override { return new BasicType( *this ); }
     240        virtual void accept( Visitor & v ) override { v.visit( this ); }
     241        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     242        virtual void print( std::ostream & os, int indent = 0 ) const override;
    243243
    244244        bool isInteger() const;
    … …  
    270270        bool is_array() const { return isStatic || isVarLen || dimension; }
    271271
    272         virtual bool isComplete() const { return ! isVarLen; }
    273 
    274         virtual PointerType *clone() const { return new PointerType( *this ); }
    275         virtual void accept( Visitor & v ) { v.visit( this ); }
    276         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    277         virtual void print( std::ostream & os, int indent = 0 ) const;
     272        virtual bool isComplete() const override { return ! isVarLen; }
     273
     274        virtual PointerType *clone() const override { return new PointerType( *this ); }
     275        virtual void accept( Visitor & v ) override { v.visit( this ); }
     276        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     277        virtual void print( std::ostream & os, int indent = 0 ) const override;
    278278};
    279279
    … …  
    298298        void set_isStatic( bool newValue ) { isStatic = newValue; }
    299299
    300         virtual bool isComplete() const { return ! isVarLen; }
    301 
    302         virtual ArrayType *clone() const { return new ArrayType( *this ); }
    303         virtual void accept( Visitor & v ) { v.visit( this ); }
    304         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    305         virtual void print( std::ostream & os, int indent = 0 ) const;
     300        virtual bool isComplete() const override { return ! isVarLen; }
     301
     302        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
     303        virtual void accept( Visitor & v ) override { v.visit( this ); }
     304        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     305        virtual void print( std::ostream & os, int indent = 0 ) const override;
    306306};
    307307
    … …  
    317317        void set_base( Type *newValue ) { base = newValue; }
    318318
    319         virtual int referenceDepth() const;
     319        virtual int referenceDepth() const override;
    320320
    321321        // Since reference types act like value types, their size is the size of the base.
    322322        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
    323323        // the number of values are disallowed.
    324         virtual unsigned size() const { return base->size(); }
    325 
    326         virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
    327         virtual void accept( Visitor & v ) { v.visit( this ); }
    328         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    329         virtual void print( std::ostream & os, int indent = 0 ) const;
     324        virtual unsigned size() const override { return base->size(); }
     325
     326        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
     327        virtual void accept( Visitor & v ) override { v.visit( this ); }
     328        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     329        virtual void print( std::ostream & os, int indent = 0 ) const override;
    330330};
    331331
    … …  
    351351        bool isTtype() const;
    352352
    353         virtual FunctionType *clone() const { return new FunctionType( *this ); }
    354         virtual void accept( Visitor & v ) { v.visit( this ); }
    355         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    356         virtual void print( std::ostream & os, int indent = 0 ) const;
     353        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
     354        virtual void accept( Visitor & v ) override { v.visit( this ); }
     355        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     356        virtual void print( std::ostream & os, int indent = 0 ) const override;
    357357};
    358358
    … …  
    373373        void set_hoistType( bool newValue ) { hoistType = newValue; }
    374374
    375         virtual ReferenceToType *clone() const = 0;
    376         virtual void accept( Visitor & v ) = 0;
    377         virtual Type *acceptMutator( Mutator & m ) = 0;
    378         virtual void print( std::ostream & os, int indent = 0 ) const;
     375        virtual ReferenceToType *clone() const override = 0;
     376        virtual void accept( Visitor & v ) override = 0;
     377        virtual Type *acceptMutator( Mutator & m ) override = 0;
     378        virtual void print( std::ostream & os, int indent = 0 ) const override;
    379379
    380380        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
    … …  
    400400        std::list<TypeDecl*> * get_baseParameters();
    401401
    402         virtual bool isComplete() const;
     402        virtual bool isComplete() const override;
    403403
    404404        /// Looks up the members of this struct named "name" and places them into "foundDecls".
    405405        /// Clones declarations into "foundDecls", caller responsible for freeing
    406         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
    407 
    408         virtual StructInstType *clone() const { return new StructInstType( *this ); }
    409         virtual void accept( Visitor & v ) { v.visit( this ); }
    410         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    411 
    412         virtual void print( std::ostream & os, int indent = 0 ) const;
     406        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
     407
     408        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
     409        virtual void accept( Visitor & v ) override { v.visit( this ); }
     410        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     411
     412        virtual void print( std::ostream & os, int indent = 0 ) const override;
    413413  private:
    414         virtual std::string typeString() const;
     414        virtual std::string typeString() const override;
    415415};
    416416
    … …  
    432432        std::list< TypeDecl * > * get_baseParameters();
    433433
    434         virtual bool isComplete() const;
     434        virtual bool isComplete() const override;
    435435
    436436        /// looks up the members of this union named "name" and places them into "foundDecls"
    437437        /// Clones declarations into "foundDecls", caller responsible for freeing
    438         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
    439 
    440         virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
    441         virtual void accept( Visitor & v ) { v.visit( this ); }
    442         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    443 
    444         virtual void print( std::ostream & os, int indent = 0 ) const;
     438        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
     439
     440        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
     441        virtual void accept( Visitor & v ) override { v.visit( this ); }
     442        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     443
     444        virtual void print( std::ostream & os, int indent = 0 ) const override;
    445445  private:
    446         virtual std::string typeString() const;
     446        virtual std::string typeString() const override;
    447447};
    448448
    … …  
    461461        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
    462462
    463         virtual bool isComplete() const;
    464 
    465         virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
    466         virtual void accept( Visitor & v ) { v.visit( this ); }
    467         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     463        virtual bool isComplete() const override;
     464
     465        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
     466        virtual void accept( Visitor & v ) override { v.visit( this ); }
     467        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    468468  private:
    469         virtual std::string typeString() const;
     469        virtual std::string typeString() const override;
    470470};
    471471
    … …  
    482482        ~TraitInstType();
    483483
    484         virtual bool isComplete() const;
    485 
    486         virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
    487         virtual void accept( Visitor & v ) { v.visit( this ); }
    488         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
     484        virtual bool isComplete() const override;
     485
     486        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
     487        virtual void accept( Visitor & v ) override { v.visit( this ); }
     488        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    489489  private:
    490         virtual std::string typeString() const;
     490        virtual std::string typeString() const override;
    491491};
    492492
    … …  
    509509        void set_isFtype( bool newValue ) { isFtype = newValue; }
    510510
    511         virtual bool isComplete() const;
    512 
    513         virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
    514         virtual void accept( Visitor & v ) { v.visit( this ); }
    515         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    516         virtual void print( std::ostream & os, int indent = 0 ) const;
     511        virtual bool isComplete() const override;
     512
     513        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
     514        virtual void accept( Visitor & v ) override { v.visit( this ); }
     515        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     516        virtual void print( std::ostream & os, int indent = 0 ) const override;
    517517  private:
    518         virtual std::string typeString() const;
     518        virtual std::string typeString() const override;
    519519};
    520520
    … …  
    532532
    533533        std::list<Type *> & get_types() { return types; }
    534         virtual unsigned size() const { return types.size(); };
     534        virtual unsigned size() const override { return types.size(); };
    535535
    536536        // For now, this is entirely synthetic -- tuple types always have unnamed members.
    … …  
    541541        iterator end() { return types.end(); }
    542542
    543         virtual Type * getComponent( unsigned i ) {
     543        virtual Type * getComponent( unsigned i ) override {
    544544                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
    545545                return *(begin()+i);
    546546        }
    547547
    548         // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
    549 
    550         virtual TupleType *clone() const { return new TupleType( *this ); }
    551         virtual void accept( Visitor & v ) { v.visit( this ); }
    552         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    553         virtual void print( std::ostream & os, int indent = 0 ) const;
     548        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
     549
     550        virtual TupleType *clone() const override { return new TupleType( *this ); }
     551        virtual void accept( Visitor & v ) override { v.visit( this ); }
     552        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     553        virtual void print( std::ostream & os, int indent = 0 ) const override;
    554554};
    555555
    … …  
    565565        void set_expr( Expression *newValue ) { expr = newValue; }
    566566
    567         virtual bool isComplete() const { assert( false ); return false; }
    568 
    569         virtual TypeofType *clone() const { return new TypeofType( *this ); }
    570         virtual void accept( Visitor & v ) { v.visit( this ); }
    571         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    572         virtual void print( std::ostream & os, int indent = 0 ) const;
     567        virtual bool isComplete() const override { assert( false ); return false; }
     568
     569        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
     570        virtual void accept( Visitor & v ) override { v.visit( this ); }
     571        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     572        virtual void print( std::ostream & os, int indent = 0 ) const override;
    573573};
    574574
    … …  
    594594        void set_isType( bool newValue ) { isType = newValue; }
    595595
    596         virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
    597 
    598         virtual AttrType *clone() const { return new AttrType( *this ); }
    599         virtual void accept( Visitor & v ) { v.visit( this ); }
    600         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    601         virtual void print( std::ostream & os, int indent = 0 ) const;
     596        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
     597
     598        virtual AttrType *clone() const override { return new AttrType( *this ); }
     599        virtual void accept( Visitor & v ) override { v.visit( this ); }
     600        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     601        virtual void print( std::ostream & os, int indent = 0 ) const override;
    602602};
    603603
    … …  
    608608        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    609609
    610         virtual bool isComplete() const{ return true; } // xxx - is this right?
    611 
    612         virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
    613         virtual void accept( Visitor & v ) { v.visit( this ); }
    614         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    615         virtual void print( std::ostream & os, int indent = 0 ) const;
     610        virtual bool isComplete() const override{ return true; } // xxx - is this right?
     611
     612        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
     613        virtual void accept( Visitor & v ) override { v.visit( this ); }
     614        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     615        virtual void print( std::ostream & os, int indent = 0 ) const override;
    616616};
    617617
    … …  
    622622        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    623623
    624         virtual ZeroType *clone() const { return new ZeroType( *this ); }
    625         virtual void accept( Visitor & v ) { v.visit( this ); }
    626         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    627         virtual void print( std::ostream & os, int indent = 0 ) const;
     624        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
     625        virtual void accept( Visitor & v ) override { v.visit( this ); }
     626        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     627        virtual void print( std::ostream & os, int indent = 0 ) const override;
    628628};
    629629
    … …  
    634634        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    635635
    636         virtual OneType *clone() const { return new OneType( *this ); }
    637         virtual void accept( Visitor & v ) { v.visit( this ); }
    638         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    639         virtual void print( std::ostream & os, int indent = 0 ) const;
    640 };
    641 
    642 std::ostream & operator<<( std::ostream & out, const Type * type );
     636        virtual OneType *clone() const override { return new OneType( *this ); }
     637        virtual void accept( Visitor & v ) override { v.visit( this ); }
     638        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     639        virtual void print( std::ostream & os, int indent = 0 ) const override;
     640};
    643641
    644642// Local Variables: //

  • src/SynTree/Visitor.h

    r201aeb9 rd67cdb7  
    2525  public:
    2626        // visit: Default implementation of all functions visits the children
    27     // of the given syntax node, but performs no other action.
     27        // of the given syntax node, but performs no other action.
    2828
    2929        virtual void visit( ObjectDecl *objectDecl );

  • src/SynTree/module.mk

    r201aeb9 rd67cdb7  
    4848       SynTree/Visitor.cc \
    4949       SynTree/Mutator.cc \
    50        SynTree/AddStmtVisitor.cc \
    5150       SynTree/TypeSubstitution.cc \
    5251       SynTree/Attribute.cc \
Note: See TracChangeset for help on using the changeset viewer.