Changeset 640b3df for src/SynTree/Type.h


Ignore:
Timestamp:
Feb 21, 2023, 4:24:34 PM (3 years ago)
Author:
caparson <caparson@…>
Branches:
ADT, ast-experimental, master
Children:
257a8f5, ce44c5f
Parents:
1180175 (diff), 9a533ba (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Type.h

    r1180175 r640b3df  
    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+
     26#include "Common/utility.h"  // for toCString
    2627#include "Mutator.h"         // for Mutator
    2728#include "SynTree.h"         // for AST nodes
    … …  
    124125                bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
    125126                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
     127                        return is_const    <= other.is_const        // Any non-const converts to const without cost
     128                                && is_volatile <= other.is_volatile             // Any non-volatile converts to volatile without cost
     129                                && is_mutex    >= other.is_mutex                // Any mutex converts to non-mutex without cost
     130                                && is_atomic   == other.is_atomic;              // No conversion from atomic to non atomic is free
    130131                }
    131132                bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
    … …  
    189190        virtual TypeSubstitution genericSubstitution() const;
    190191
    191         virtual Type *clone() const = 0;
     192        virtual Type * clone() const = 0;
    192193        virtual void accept( Visitor & v ) = 0;
    193194        virtual void accept( Visitor & v ) const = 0;
    194         virtual Type *acceptMutator( Mutator & m ) = 0;
     195        virtual Type * acceptMutator( Mutator & m ) = 0;
    195196        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    196197};
    … …  
    207208        virtual bool isComplete() const override { return false; }
    208209
    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 ); }
     210        virtual VoidType * clone() const override { return new VoidType( *this ); }
     211        virtual void accept( Visitor & v ) override { v.visit( this ); }
     212        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     213        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    213214        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    214215};
    … …  
    259260        // GENERATED END
    260261
    261         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
     262        static const char * typeNames[];                                        // string names for basic types, MUST MATCH with Kind
    262263
    263264        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    … …  
    266267        void set_kind( Kind newValue ) { kind = newValue; }
    267268
    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 ); }
     269        virtual BasicType * clone() const override { return new BasicType( *this ); }
     270        virtual void accept( Visitor & v ) override { v.visit( this ); }
     271        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     272        virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    272273        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    273274        bool isInteger() const;
    … …  
    279280
    280281        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
    281         Expression *dimension;
     282        Expression * dimension;
    282283        bool isVarLen;
    283284        bool isStatic;
    284285
    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 * >() );
     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 * >() );
    287288        PointerType( const PointerType& );
    288289        virtual ~PointerType();
    289290
    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; }
     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; }
    294295        bool get_isVarLen() { return isVarLen; }
    295296        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
    … …  
    301302        virtual bool isComplete() const override { return ! isVarLen; }
    302303
    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 ); }
     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 ); }
    307308        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    308309};
    … …  
    310311class ArrayType : public Type {
    311312  public:
    312         Type *base;
    313         Expression *dimension;
     313        Type * base;
     314        Expression * dimension;
    314315        bool isVarLen;
    315316        bool isStatic;
    316317
    317         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     318        ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    318319        ArrayType( const ArrayType& );
    319320        virtual ~ArrayType();
    320321
    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; }
     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; }
    325326        bool get_isVarLen() { return isVarLen; }
    326327        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
    … …  
    333334        virtual bool isComplete() const override { return dimension || isVarLen; }
    334335
    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 ); }
     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 ); }
    339340        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    340341};
    … …  
    348349        virtual ~QualifiedType();
    349350
    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 ); }
     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 ); }
    354355        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    355356};
    … …  
    357358class ReferenceType : public Type {
    358359public:
    359         Type *base;
    360 
    361         ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
     360        Type * base;
     361
     362        ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    362363        ReferenceType( const ReferenceType & );
    363364        virtual ~ReferenceType();
    364365
    365         Type *get_base() { return base; }
    366         void set_base( Type *newValue ) { base = newValue; }
     366        Type * get_base() { return base; }
     367        void set_base( Type * newValue ) { base = newValue; }
    367368
    368369        virtual int referenceDepth() const override;
    … …  
    375376        virtual TypeSubstitution genericSubstitution() const override;
    376377
    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 ); }
     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 ); }
    381382        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    382383};
    … …  
    405406        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
    406407
    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 ); }
     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 ); }
    411412        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    412413};
    … …  
    414415class ReferenceToType : public Type {
    415416  public:
    416         std::list< Expression* > parameters;
     417        std::list< Expression * > parameters;
    417418        std::string name;
    418419        bool hoistType;
    … …  
    428429        void set_hoistType( bool newValue ) { hoistType = newValue; }
    429430
    430         virtual ReferenceToType *clone() const override = 0;
     431        virtual ReferenceToType * clone() const override = 0;
    431432        virtual void accept( Visitor & v ) override = 0;
    432         virtual Type *acceptMutator( Mutator & m ) override = 0;
     433        virtual Type * acceptMutator( Mutator & m ) override = 0;
    433434        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    434435
    … …  
    443444        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
    444445        // where the structure used in this type is actually defined
    445         StructDecl *baseStruct;
     446        StructDecl * baseStruct;
    446447
    447448        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
    … …  
    449450        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
    450451
    451         StructDecl *get_baseStruct() const { return baseStruct; }
    452         void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
     452        StructDecl * get_baseStruct() const { return baseStruct; }
     453        void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; }
    453454
    454455        /// Accesses generic parameters of base struct (NULL if none such)
    … …  
    466467        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
    467468
    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 ); }
     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 ); }
    472473
    473474        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    481482        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
    482483        // where the union used in this type is actually defined
    483         UnionDecl *baseUnion;
     484        UnionDecl * baseUnion;
    484485
    485486        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
    … …  
    487488        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
    488489
    489         UnionDecl *get_baseUnion() const { return baseUnion; }
     490        UnionDecl * get_baseUnion() const { return baseUnion; }
    490491        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
    491492
    … …  
    504505        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
    505506
    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 ); }
     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 ); }
    510511
    511512        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    519520        // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
    520521        // where the enum used in this type is actually defined
    521         EnumDecl *baseEnum = nullptr;
     522        EnumDecl * baseEnum = nullptr;
    522523
    523524        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
    … …  
    525526        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
    526527
    527         EnumDecl *get_baseEnum() const { return baseEnum; }
    528         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
     528        EnumDecl * get_baseEnum() const { return baseEnum; }
     529        void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; }
    529530
    530531        virtual bool isComplete() const override;
    … …  
    532533        virtual AggregateDecl * getAggr() const override;
    533534
    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 ); }
     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 ); }
    538539
    539540        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    556557        virtual bool isComplete() const override;
    557558
    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 ); }
     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 ); }
    562563  private:
    563564        virtual std::string typeString() const override;
    … …  
    569570        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
    570571        // where the type used here is actually defined
    571         TypeDecl *baseType;
     572        TypeDecl * baseType;
    572573        bool isFtype;
    573574
    574         TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
     575        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    575576        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    576577        TypeInstType( const TypeInstType & other );
    577578        ~TypeInstType();
    578579
    579         TypeDecl *get_baseType() const { return baseType; }
    580         void set_baseType( TypeDecl *newValue );
     580        TypeDecl * get_baseType() const { return baseType; }
     581        void set_baseType( TypeDecl * newValue );
    581582        bool get_isFtype() const { return isFtype; }
    582583        void set_isFtype( bool newValue ) { isFtype = newValue; }
    … …  
    584585        virtual bool isComplete() const override;
    585586
    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 ); }
     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 ); }
    590591        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    591592  private:
    … …  
    622623        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
    623624
    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 ); }
     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 ); }
    628629        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    629630};
    … …  
    631632class TypeofType : public Type {
    632633  public:
    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,
     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,
    638639                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    639640        TypeofType( const TypeofType& );
    640641        virtual ~TypeofType();
    641642
    642         Expression *get_expr() const { return expr; }
    643         void set_expr( Expression *newValue ) { expr = newValue; }
     643        Expression * get_expr() const { return expr; }
     644        void set_expr( Expression * newValue ) { expr = newValue; }
    644645
    645646        virtual bool isComplete() const override { assert( false ); return false; }
    646647
    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 ); }
     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 ); }
    651652        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    652653};
    … …  
    654655class VTableType : public Type {
    655656public:
    656         Type *base;
    657 
    658         VTableType( const Type::Qualifiers & tq, Type *base,
     657        Type * base;
     658
     659        VTableType( const Type::Qualifiers & tq, Type * base,
    659660                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    660661        VTableType( const VTableType & );
    661662        virtual ~VTableType();
    662663
    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 ); }
     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 ); }
    670671        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    671672};
    … …  
    674675  public:
    675676        std::string name;
    676         Expression *expr;
    677         Type *type;
     677        Expression * expr;
     678        Type * type;
    678679        bool isType;
    679680
    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 * >()  );
     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 * >()  );
    682683        AttrType( const AttrType& );
    683684        virtual ~AttrType();
    … …  
    685686        const std::string & get_name() const { return name; }
    686687        void set_name( const std::string & newValue ) { name = 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; }
     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; }
    691692        bool get_isType() const { return isType; }
    692693        void set_isType( bool newValue ) { isType = newValue; }
    … …  
    694695        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
    695696
    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 ); }
     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 ); }
    700701        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    701702};
    … …  
    709710        virtual bool isComplete() const override{ return true; } // xxx - is this right?
    710711
    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 ); }
     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 ); }
    715716        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    716717};
    … …  
    722723        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    723724
    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 ); }
     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 ); }
    728729        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    729730};
    … …  
    735736        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
    736737
    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 ); }
     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 ); }
    741742        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    742743};
    … …  
    746747        GlobalScopeType();
    747748
    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 ); }
     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 ); }
    752753        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    753754};
Note: See TracChangeset for help on using the changeset viewer.