Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 7b5694da33510256b93c764421e1bea0be79d671) +++ src/SynTree/Type.h (revision 1c80f20f755bb236dd5a5cddd492b72164fede40) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Wed Jul 14 15:40:00 2021 -// Update Count : 171 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Feb 13 17:13:52 2023 +// Update Count : 173 // @@ -189,8 +189,8 @@ virtual TypeSubstitution genericSubstitution() const; - virtual Type *clone() const = 0; + virtual Type * clone() const = 0; virtual void accept( Visitor & v ) = 0; virtual void accept( Visitor & v ) const = 0; - virtual Type *acceptMutator( Mutator & m ) = 0; + virtual Type * acceptMutator( Mutator & m ) = 0; virtual void print( std::ostream & os, Indenter indent = {} ) const; }; @@ -207,8 +207,8 @@ virtual bool isComplete() const override { return false; } - virtual VoidType *clone() const override { return new VoidType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual VoidType * clone() const override { return new VoidType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -259,5 +259,5 @@ // GENERATED END - static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind + static const char * typeNames[]; // string names for basic types, MUST MATCH with Kind BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); @@ -266,8 +266,8 @@ void set_kind( Kind newValue ) { kind = newValue; } - virtual BasicType *clone() const override { return new BasicType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual BasicType * clone() const override { return new BasicType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; bool isInteger() const; @@ -279,17 +279,17 @@ // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] ) - Expression *dimension; + Expression * dimension; bool isVarLen; bool isStatic; - PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); PointerType( const PointerType& ); virtual ~PointerType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } - Expression *get_dimension() { return dimension; } - void set_dimension( Expression *newValue ) { dimension = newValue; } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } + Expression * get_dimension() { return dimension; } + void set_dimension( Expression * newValue ) { dimension = newValue; } bool get_isVarLen() { return isVarLen; } void set_isVarLen( bool newValue ) { isVarLen = newValue; } @@ -301,8 +301,8 @@ virtual bool isComplete() const override { return ! isVarLen; } - virtual PointerType *clone() const override { return new PointerType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual PointerType * clone() const override { return new PointerType( * this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -310,17 +310,17 @@ class ArrayType : public Type { public: - Type *base; - Expression *dimension; + Type * base; + Expression * dimension; bool isVarLen; bool isStatic; - ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); ArrayType( const ArrayType& ); virtual ~ArrayType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } - Expression *get_dimension() { return dimension; } - void set_dimension( Expression *newValue ) { dimension = newValue; } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } + Expression * get_dimension() { return dimension; } + void set_dimension( Expression * newValue ) { dimension = newValue; } bool get_isVarLen() { return isVarLen; } void set_isVarLen( bool newValue ) { isVarLen = newValue; } @@ -333,8 +333,8 @@ virtual bool isComplete() const override { return dimension || isVarLen; } - virtual ArrayType *clone() const override { return new ArrayType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual ArrayType * clone() const override { return new ArrayType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -348,8 +348,8 @@ virtual ~QualifiedType(); - virtual QualifiedType *clone() const override { return new QualifiedType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual QualifiedType * clone() const override { return new QualifiedType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -357,12 +357,12 @@ class ReferenceType : public Type { public: - Type *base; - - ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + Type * base; + + ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); ReferenceType( const ReferenceType & ); virtual ~ReferenceType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } virtual int referenceDepth() const override; @@ -375,8 +375,8 @@ virtual TypeSubstitution genericSubstitution() const override; - virtual ReferenceType *clone() const override { return new ReferenceType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual ReferenceType * clone() const override { return new ReferenceType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -405,8 +405,8 @@ bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; } - virtual FunctionType *clone() const override { return new FunctionType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual FunctionType * clone() const override { return new FunctionType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -414,5 +414,5 @@ class ReferenceToType : public Type { public: - std::list< Expression* > parameters; + std::list< Expression * > parameters; std::string name; bool hoistType; @@ -428,7 +428,7 @@ void set_hoistType( bool newValue ) { hoistType = newValue; } - virtual ReferenceToType *clone() const override = 0; + virtual ReferenceToType * clone() const override = 0; virtual void accept( Visitor & v ) override = 0; - virtual Type *acceptMutator( Mutator & m ) override = 0; + virtual Type * acceptMutator( Mutator & m ) override = 0; virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -443,5 +443,5 @@ // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree, // where the structure used in this type is actually defined - StructDecl *baseStruct; + StructDecl * baseStruct; StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {} @@ -449,6 +449,6 @@ StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {} - StructDecl *get_baseStruct() const { return baseStruct; } - void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; } + StructDecl * get_baseStruct() const { return baseStruct; } + void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; } /// Accesses generic parameters of base struct (NULL if none such) @@ -466,8 +466,8 @@ void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override; - virtual StructInstType *clone() const override { return new StructInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual StructInstType * clone() const override { return new StructInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -481,5 +481,5 @@ // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree, // where the union used in this type is actually defined - UnionDecl *baseUnion; + UnionDecl * baseUnion; UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {} @@ -487,5 +487,5 @@ UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {} - UnionDecl *get_baseUnion() const { return baseUnion; } + UnionDecl * get_baseUnion() const { return baseUnion; } void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; } @@ -504,8 +504,8 @@ void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override; - virtual UnionInstType *clone() const override { return new UnionInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual UnionInstType * clone() const override { return new UnionInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -519,5 +519,5 @@ // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree, // where the enum used in this type is actually defined - EnumDecl *baseEnum = nullptr; + EnumDecl * baseEnum = nullptr; EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {} @@ -525,6 +525,6 @@ EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {} - EnumDecl *get_baseEnum() const { return baseEnum; } - void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; } + EnumDecl * get_baseEnum() const { return baseEnum; } + void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; } virtual bool isComplete() const override; @@ -532,8 +532,8 @@ virtual AggregateDecl * getAggr() const override; - virtual EnumInstType *clone() const override { return new EnumInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual EnumInstType * clone() const override { return new EnumInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; @@ -556,8 +556,8 @@ virtual bool isComplete() const override; - virtual TraitInstType *clone() const override { return new TraitInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TraitInstType * clone() const override { return new TraitInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } private: virtual std::string typeString() const override; @@ -569,14 +569,14 @@ // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree, // where the type used here is actually defined - TypeDecl *baseType; + TypeDecl * baseType; bool isFtype; - TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TypeInstType( const TypeInstType & other ); ~TypeInstType(); - TypeDecl *get_baseType() const { return baseType; } - void set_baseType( TypeDecl *newValue ); + TypeDecl * get_baseType() const { return baseType; } + void set_baseType( TypeDecl * newValue ); bool get_isFtype() const { return isFtype; } void set_isFtype( bool newValue ) { isFtype = newValue; } @@ -584,8 +584,8 @@ virtual bool isComplete() const override; - virtual TypeInstType *clone() const override { return new TypeInstType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TypeInstType * clone() const override { return new TypeInstType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; private: @@ -622,8 +622,8 @@ // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness - virtual TupleType *clone() const override { return new TupleType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TupleType * clone() const override { return new TupleType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -631,22 +631,22 @@ class TypeofType : public Type { public: - Expression *expr; ///< expression to take the type of + Expression * expr; ///< expression to take the type of bool is_basetypeof; ///< true iff is basetypeof type - TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, + TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TypeofType( const TypeofType& ); virtual ~TypeofType(); - Expression *get_expr() const { return expr; } - void set_expr( Expression *newValue ) { expr = newValue; } + Expression * get_expr() const { return expr; } + void set_expr( Expression * newValue ) { expr = newValue; } virtual bool isComplete() const override { assert( false ); return false; } - virtual TypeofType *clone() const override { return new TypeofType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual TypeofType * clone() const override { return new TypeofType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -654,18 +654,18 @@ class VTableType : public Type { public: - Type *base; - - VTableType( const Type::Qualifiers & tq, Type *base, + Type * base; + + VTableType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); VTableType( const VTableType & ); virtual ~VTableType(); - Type *get_base() { return base; } - void set_base( Type *newValue ) { base = newValue; } - - virtual VTableType *clone() const override { return new VTableType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + Type * get_base() { return base; } + void set_base( Type * newValue ) { base = newValue; } + + virtual VTableType * clone() const override { return new VTableType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -674,10 +674,10 @@ public: std::string name; - Expression *expr; - Type *type; + Expression * expr; + Type * type; bool isType; - AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); AttrType( const AttrType& ); virtual ~AttrType(); @@ -685,8 +685,8 @@ const std::string & get_name() const { return name; } void set_name( const std::string & newValue ) { name = newValue; } - Expression *get_expr() const { return expr; } - void set_expr( Expression *newValue ) { expr = newValue; } - Type *get_type() const { return type; } - void set_type( Type *newValue ) { type = newValue; } + Expression * get_expr() const { return expr; } + void set_expr( Expression * newValue ) { expr = newValue; } + Type * get_type() const { return type; } + void set_type( Type * newValue ) { type = newValue; } bool get_isType() const { return isType; } void set_isType( bool newValue ) { isType = newValue; } @@ -694,8 +694,8 @@ virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here - virtual AttrType *clone() const override { return new AttrType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual AttrType * clone() const override { return new AttrType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -709,8 +709,8 @@ virtual bool isComplete() const override{ return true; } // xxx - is this right? - virtual VarArgsType *clone() const override { return new VarArgsType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual VarArgsType * clone() const override { return new VarArgsType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -722,8 +722,8 @@ ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - virtual ZeroType *clone() const override { return new ZeroType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual ZeroType * clone() const override { return new ZeroType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -735,8 +735,8 @@ OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); - virtual OneType *clone() const override { return new OneType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual OneType * clone() const override { return new OneType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; }; @@ -746,8 +746,8 @@ GlobalScopeType(); - virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); } - virtual void accept( Visitor & v ) override { v.visit( this ); } - virtual void accept( Visitor & v ) const override { v.visit( this ); } - virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } + virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); } + virtual void accept( Visitor & v ) override { v.visit( this ); } + virtual void accept( Visitor & v ) const override { v.visit( this ); } + virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; };