Changeset 24d6572 for src/SynTree/Type.h


Ignore:
Timestamp:
Jun 12, 2023, 2:45:32 PM (2 years ago)
Author:
Fangren Yu <f37yu@…>
Branches:
ast-experimental, master
Children:
62d62db
Parents:
34b4268 (diff), 251ce80 (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' into ast-experimental

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Type.h

    r34b4268 r24d6572  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jul 14 15:40:00 2021
    13 // Update Count     : 171
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Feb 19 22:37:10 2023
     13// Update Count     : 176
    1414//
    1515
    … …  
    2323
    2424#include "BaseSyntaxNode.h"  // for BaseSyntaxNode
    25 #include "Common/utility.h"  // for operator+
     25#include "Common/Iterate.hpp"// for operator+
    2626#include "Mutator.h"         // for Mutator
    2727#include "SynTree.h"         // for AST nodes
    … …  
    124124                bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
    125125                bool operator<=( Qualifiers other ) const {
    126                         return is_const    <= other.is_const        //Any non-const converts to const without cost
    127                                         && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
    128                                         && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
    129                                         && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
     126                        return is_const    <= other.is_const        // Any non-const converts to const without cost
     127                                && is_volatile <= other.is_volatile             // Any non-volatile converts to volatile without cost
     128                                && is_mutex    >= other.is_mutex                // Any mutex converts to non-mutex without cost
     129                                && is_atomic   == other.is_atomic;              // No conversion from atomic to non atomic is free
    130130                }
    131131                bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
    … …  
    185185        virtual bool isComplete() const { return true; }
    186186
    187         virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
     187        virtual AggregateDecl * getAggr() const;
    188188
    189189        virtual TypeSubstitution genericSubstitution() const;
    190190
    191         virtual Type *clone() const = 0;
     191        virtual Type * clone() const = 0;
    192192        virtual void accept( Visitor & v ) = 0;
    193193        virtual void accept( Visitor & v ) const = 0;
    194         virtual Type *acceptMutator( Mutator & m ) = 0;
     194        virtual Type * acceptMutator( Mutator & m ) = 0;
    195195        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    196196};
    … …  
    207207        virtual bool isComplete() const override { return false; }
    208208
    209         virtual VoidType *clone() const override { return new VoidType( *this ); }
    210         virtual void accept( Visitor & v ) override { v.visit( this ); }
    211         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    212         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     209        virtual VoidType * clone() const override { return new VoidType( *this ); }
     210        virtual void accept( Visitor & v ) override { v.visit( this ); }
     211        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     212        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    213213        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    214214};
    … …  
    259259        // GENERATED END
    260260
    261         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
     261        static const char * typeNames[];                                        // string names for basic types, MUST MATCH with Kind
    262262
    263263        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    … …  
    266266        void set_kind( Kind newValue ) { kind = newValue; }
    267267
    268         virtual BasicType *clone() const override { return new BasicType( *this ); }
    269         virtual void accept( Visitor & v ) override { v.visit( this ); }
    270         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    271         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    272         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    273         bool isWholeNumber() const;
     268        virtual BasicType * clone() const override { return new BasicType( *this ); }
     269        virtual void accept( Visitor & v ) override { v.visit( this ); }
     270        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     271        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     272        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    274273        bool isInteger() const;
    275274};
    … …  
    280279
    281280        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
    282         Expression *dimension;
     281        Expression * dimension;
    283282        bool isVarLen;
    284283        bool isStatic;
    285284
    286         PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    287         PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     285        PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     286        PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    288287        PointerType( const PointerType& );
    289288        virtual ~PointerType();
    290289
    291         Type *get_base() { return base; }
    292         void set_base( Type *newValue ) { base = newValue; }
    293         Expression *get_dimension() { return dimension; }
    294         void set_dimension( Expression *newValue ) { dimension = newValue; }
     290        Type * get_base() { return base; }
     291        void set_base( Type * newValue ) { base = newValue; }
     292        Expression * get_dimension() { return dimension; }
     293        void set_dimension( Expression * newValue ) { dimension = newValue; }
    295294        bool get_isVarLen() { return isVarLen; }
    296295        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
    … …  
    302301        virtual bool isComplete() const override { return ! isVarLen; }
    303302
    304         virtual PointerType *clone() const override { return new PointerType( *this ); }
    305         virtual void accept( Visitor & v ) override { v.visit( this ); }
    306         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    307         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     303        virtual PointerType * clone() const override { return new PointerType( * this ); }
     304        virtual void accept( Visitor & v ) override { v.visit( this ); }
     305        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     306        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    308307        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    309308};
    … …  
    311310class ArrayType : public Type {
    312311  public:
    313         Type *base;
    314         Expression *dimension;
     312        Type * base;
     313        Expression * dimension;
    315314        bool isVarLen;
    316315        bool isStatic;
    317316
    318         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     317        ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    319318        ArrayType( const ArrayType& );
    320319        virtual ~ArrayType();
    321320
    322         Type *get_base() { return base; }
    323         void set_base( Type *newValue ) { base = newValue; }
    324         Expression *get_dimension() { return dimension; }
    325         void set_dimension( Expression *newValue ) { dimension = newValue; }
     321        Type * get_base() { return base; }
     322        void set_base( Type * newValue ) { base = newValue; }
     323        Expression * get_dimension() { return dimension; }
     324        void set_dimension( Expression * newValue ) { dimension = newValue; }
    326325        bool get_isVarLen() { return isVarLen; }
    327326        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
    … …  
    334333        virtual bool isComplete() const override { return dimension || isVarLen; }
    335334
    336         virtual ArrayType *clone() const override { return new ArrayType( *this ); }
    337         virtual void accept( Visitor & v ) override { v.visit( this ); }
    338         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    339         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     335        virtual ArrayType * clone() const override { return new ArrayType( *this ); }
     336        virtual void accept( Visitor & v ) override { v.visit( this ); }
     337        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     338        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    340339        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    341340};
    … …  
    349348        virtual ~QualifiedType();
    350349
    351         virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
    352         virtual void accept( Visitor & v ) override { v.visit( this ); }
    353         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    354         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     350        virtual QualifiedType * clone() const override { return new QualifiedType( *this ); }
     351        virtual void accept( Visitor & v ) override { v.visit( this ); }
     352        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     353        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    355354        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    356355};
    … …  
    358357class ReferenceType : public Type {
    359358public:
    360         Type *base;
    361 
    362         ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     359        Type * base;
     360
     361        ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    363362        ReferenceType( const ReferenceType & );
    364363        virtual ~ReferenceType();
    365364
    366         Type *get_base() { return base; }
    367         void set_base( Type *newValue ) { base = newValue; }
     365        Type * get_base() { return base; }
     366        void set_base( Type * newValue ) { base = newValue; }
    368367
    369368        virtual int referenceDepth() const override;
    … …  
    376375        virtual TypeSubstitution genericSubstitution() const override;
    377376
    378         virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
    379         virtual void accept( Visitor & v ) override { v.visit( this ); }
    380         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    381         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     377        virtual ReferenceType * clone() const override { return new ReferenceType( *this ); }
     378        virtual void accept( Visitor & v ) override { v.visit( this ); }
     379        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     380        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    382381        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    383382};
    … …  
    406405        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
    407406
    408         virtual FunctionType *clone() const override { return new FunctionType( *this ); }
    409         virtual void accept( Visitor & v ) override { v.visit( this ); }
    410         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    411         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     407        virtual FunctionType * clone() const override { return new FunctionType( *this ); }
     408        virtual void accept( Visitor & v ) override { v.visit( this ); }
     409        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     410        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    412411        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    413412};
    … …  
    415414class ReferenceToType : public Type {
    416415  public:
    417         std::list< Expression* > parameters;
     416        std::list< Expression * > parameters;
    418417        std::string name;
    419418        bool hoistType;
    … …  
    429428        void set_hoistType( bool newValue ) { hoistType = newValue; }
    430429
    431         virtual ReferenceToType *clone() const override = 0;
     430        virtual ReferenceToType * clone() const override = 0;
    432431        virtual void accept( Visitor & v ) override = 0;
    433         virtual Type *acceptMutator( Mutator & m ) override = 0;
     432        virtual Type * acceptMutator( Mutator & m ) override = 0;
    434433        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    435434
    … …  
    444443        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
    445444        // where the structure used in this type is actually defined
    446         StructDecl *baseStruct;
     445        StructDecl * baseStruct;
    447446
    448447        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
    … …  
    450449        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
    451450
    452         StructDecl *get_baseStruct() const { return baseStruct; }
    453         void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
     451        StructDecl * get_baseStruct() const { return baseStruct; }
     452        void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; }
    454453
    455454        /// Accesses generic parameters of base struct (NULL if none such)
    … …  
    467466        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
    468467
    469         virtual StructInstType *clone() const override { return new StructInstType( *this ); }
    470         virtual void accept( Visitor & v ) override { v.visit( this ); }
    471         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    472         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     468        virtual StructInstType * clone() const override { return new StructInstType( *this ); }
     469        virtual void accept( Visitor & v ) override { v.visit( this ); }
     470        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     471        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    473472
    474473        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    482481        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
    483482        // where the union used in this type is actually defined
    484         UnionDecl *baseUnion;
     483        UnionDecl * baseUnion;
    485484
    486485        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
    … …  
    488487        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
    489488
    490         UnionDecl *get_baseUnion() const { return baseUnion; }
     489        UnionDecl * get_baseUnion() const { return baseUnion; }
    491490        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
    492491
    … …  
    505504        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
    506505
    507         virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
    508         virtual void accept( Visitor & v ) override { v.visit( this ); }
    509         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    510         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     506        virtual UnionInstType * clone() const override { return new UnionInstType( *this ); }
     507        virtual void accept( Visitor & v ) override { v.visit( this ); }
     508        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     509        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    511510
    512511        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    520519        // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
    521520        // where the enum used in this type is actually defined
    522         EnumDecl *baseEnum = nullptr;
     521        EnumDecl * baseEnum = nullptr;
    523522
    524523        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
    … …  
    526525        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
    527526
    528         EnumDecl *get_baseEnum() const { return baseEnum; }
    529         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
     527        EnumDecl * get_baseEnum() const { return baseEnum; }
     528        void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; }
    530529
    531530        virtual bool isComplete() const override;
    … …  
    533532        virtual AggregateDecl * getAggr() const override;
    534533
    535         virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
    536         virtual void accept( Visitor & v ) override { v.visit( this ); }
    537         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    538         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     534        virtual EnumInstType * clone() const override { return new EnumInstType( *this ); }
     535        virtual void accept( Visitor & v ) override { v.visit( this ); }
     536        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     537        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    539538
    540539        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    557556        virtual bool isComplete() const override;
    558557
    559         virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
    560         virtual void accept( Visitor & v ) override { v.visit( this ); }
    561         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    562         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     558        virtual TraitInstType * clone() const override { return new TraitInstType( *this ); }
     559        virtual void accept( Visitor & v ) override { v.visit( this ); }
     560        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     561        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    563562  private:
    564563        virtual std::string typeString() const override;
    … …  
    570569        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
    571570        // where the type used here is actually defined
    572         TypeDecl *baseType;
     571        TypeDecl * baseType;
    573572        bool isFtype;
    574573
    575         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     574        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    576575        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    577576        TypeInstType( const TypeInstType & other );
    578577        ~TypeInstType();
    579578
    580         TypeDecl *get_baseType() const { return baseType; }
    581         void set_baseType( TypeDecl *newValue );
     579        TypeDecl * get_baseType() const { return baseType; }
     580        void set_baseType( TypeDecl * newValue );
    582581        bool get_isFtype() const { return isFtype; }
    583582        void set_isFtype( bool newValue ) { isFtype = newValue; }
    … …  
    585584        virtual bool isComplete() const override;
    586585
    587         virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
    588         virtual void accept( Visitor & v ) override { v.visit( this ); }
    589         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    590         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     586        virtual TypeInstType * clone() const override { return new TypeInstType( *this ); }
     587        virtual void accept( Visitor & v ) override { v.visit( this ); }
     588        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     589        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    591590        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    592591  private:
    … …  
    623622        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
    624623
    625         virtual TupleType *clone() const override { return new TupleType( *this ); }
    626         virtual void accept( Visitor & v ) override { v.visit( this ); }
    627         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    628         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     624        virtual TupleType * clone() const override { return new TupleType( *this ); }
     625        virtual void accept( Visitor & v ) override { v.visit( this ); }
     626        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     627        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    629628        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    630629};
    … …  
    632631class TypeofType : public Type {
    633632  public:
    634         Expression *expr;    ///< expression to take the type of
    635         bool is_basetypeof;  ///< true iff is basetypeof type
    636 
    637         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    638         TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
     633        Expression * expr;              ///< expression to take the type of
     634        bool is_basetypeof;             ///< true iff is basetypeof type
     635
     636        TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     637        TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof,
    639638                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    640639        TypeofType( const TypeofType& );
    641640        virtual ~TypeofType();
    642641
    643         Expression *get_expr() const { return expr; }
    644         void set_expr( Expression *newValue ) { expr = newValue; }
     642        Expression * get_expr() const { return expr; }
     643        void set_expr( Expression * newValue ) { expr = newValue; }
    645644
    646645        virtual bool isComplete() const override { assert( false ); return false; }
    647646
    648         virtual TypeofType *clone() const override { return new TypeofType( *this ); }
    649         virtual void accept( Visitor & v ) override { v.visit( this ); }
    650         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    651         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     647        virtual TypeofType * clone() const override { return new TypeofType( *this ); }
     648        virtual void accept( Visitor & v ) override { v.visit( this ); }
     649        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     650        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    652651        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    653652};
    … …  
    655654class VTableType : public Type {
    656655public:
    657         Type *base;
    658 
    659         VTableType( const Type::Qualifiers & tq, Type *base,
     656        Type * base;
     657
     658        VTableType( const Type::Qualifiers & tq, Type * base,
    660659                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    661660        VTableType( const VTableType & );
    662661        virtual ~VTableType();
    663662
    664         Type *get_base() { return base; }
    665         void set_base( Type *newValue ) { base = newValue; }
    666 
    667         virtual VTableType *clone() const override { return new VTableType( *this ); }
    668         virtual void accept( Visitor & v ) override { v.visit( this ); }
    669         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    670         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     663        Type * get_base() { return base; }
     664        void set_base( Type * newValue ) { base = newValue; }
     665
     666        virtual VTableType * clone() const override { return new VTableType( *this ); }
     667        virtual void accept( Visitor & v ) override { v.visit( this ); }
     668        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     669        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    671670        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    672671};
    … …  
    675674  public:
    676675        std::string name;
    677         Expression *expr;
    678         Type *type;
     676        Expression * expr;
     677        Type * type;
    679678        bool isType;
    680679
    681         AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    682         AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     680        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     681        AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    683682        AttrType( const AttrType& );
    684683        virtual ~AttrType();
    … …  
    686685        const std::string & get_name() const { return name; }
    687686        void set_name( const std::string & newValue ) { name = newValue; }
    688         Expression *get_expr() const { return expr; }
    689         void set_expr( Expression *newValue ) { expr = newValue; }
    690         Type *get_type() const { return type; }
    691         void set_type( Type *newValue ) { type = newValue; }
     687        Expression * get_expr() const { return expr; }
     688        void set_expr( Expression * newValue ) { expr = newValue; }
     689        Type * get_type() const { return type; }
     690        void set_type( Type * newValue ) { type = newValue; }
    692691        bool get_isType() const { return isType; }
    693692        void set_isType( bool newValue ) { isType = newValue; }
    … …  
    695694        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
    696695
    697         virtual AttrType *clone() const override { return new AttrType( *this ); }
    698         virtual void accept( Visitor & v ) override { v.visit( this ); }
    699         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    700         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     696        virtual AttrType * clone() const override { return new AttrType( *this ); }
     697        virtual void accept( Visitor & v ) override { v.visit( this ); }
     698        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     699        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    701700        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    702701};
    … …  
    710709        virtual bool isComplete() const override{ return true; } // xxx - is this right?
    711710
    712         virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
    713         virtual void accept( Visitor & v ) override { v.visit( this ); }
    714         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    715         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     711        virtual VarArgsType * clone() const override { return new VarArgsType( *this ); }
     712        virtual void accept( Visitor & v ) override { v.visit( this ); }
     713        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     714        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    716715        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    717716};
    … …  
    723722        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    724723
    725         virtual ZeroType *clone() const override { return new ZeroType( *this ); }
    726         virtual void accept( Visitor & v ) override { v.visit( this ); }
    727         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    728         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     724        virtual ZeroType * clone() const override { return new ZeroType( *this ); }
     725        virtual void accept( Visitor & v ) override { v.visit( this ); }
     726        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     727        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    729728        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    730729};
    … …  
    736735        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    737736
    738         virtual OneType *clone() const override { return new OneType( *this ); }
    739         virtual void accept( Visitor & v ) override { v.visit( this ); }
    740         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    741         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     737        virtual OneType * clone() const override { return new OneType( *this ); }
     738        virtual void accept( Visitor & v ) override { v.visit( this ); }
     739        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     740        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    742741        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    743742};
    … …  
    747746        GlobalScopeType();
    748747
    749         virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
    750         virtual void accept( Visitor & v ) override { v.visit( this ); }
    751         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    752         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
     748        virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); }
     749        virtual void accept( Visitor & v ) override { v.visit( this ); }
     750        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     751        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    753752        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    754753};
Note: See TracChangeset for help on using the changeset viewer.