Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision 46da46b804c2acd6916c888202a57186f41df8a8) +++ src/SynTree/AggregateDecl.cc (revision 3a7aa94e697cfe6575ffbfec969567cc0eecc91f) @@ -19,4 +19,5 @@ #include "Attribute.h" // for Attribute +#include "Common/Eval.h" // for eval #include "Common/utility.h" // for printAll, cloneAll, deleteAll #include "Declaration.h" // for AggregateDecl, TypeDecl, Declaration Index: src/SynTree/ApplicationExpr.cc =================================================================== --- src/SynTree/ApplicationExpr.cc (revision 46da46b804c2acd6916c888202a57186f41df8a8) +++ src/SynTree/ApplicationExpr.cc (revision 3a7aa94e697cfe6575ffbfec969567cc0eecc91f) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// ApplicationExpr.cc.cc -- +// ApplicationExpr.cc -- // // Author : Richard C. Bilson @@ -26,5 +26,5 @@ #include "Expression.h" // for ParamEntry, ApplicationExpr, Expression #include "InitTweak/InitTweak.h" // for getFunction -#include "ResolvExpr/typeops.h" // for extractResultType +#include "ResolvExpr/Unify.h" // for extractResultType #include "Type.h" // for Type, PointerType, FunctionType Index: src/SynTree/BasicType.cc =================================================================== --- src/SynTree/BasicType.cc (revision 46da46b804c2acd6916c888202a57186f41df8a8) +++ src/SynTree/BasicType.cc (revision 3a7aa94e697cfe6575ffbfec969567cc0eecc91f) @@ -29,21 +29,4 @@ } -bool BasicType::isWholeNumber() const { - return kind == Bool || - kind ==Char || - kind == SignedChar || - kind == UnsignedChar || - kind == ShortSignedInt || - kind == ShortUnsignedInt || - kind == SignedInt || - kind == UnsignedInt || - kind == LongSignedInt || - kind == LongUnsignedInt || - kind == LongLongSignedInt || - kind ==LongLongUnsignedInt || - kind == SignedInt128 || - kind == UnsignedInt128; -} - bool BasicType::isInteger() const { return kind <= UnsignedInt128; Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision 46da46b804c2acd6916c888202a57186f41df8a8) +++ src/SynTree/FunctionDecl.cc (revision 3a7aa94e697cfe6575ffbfec969567cc0eecc91f) @@ -87,4 +87,10 @@ } // if + if ( !withExprs.empty() ) { + os << indent << "... with clause" << std::endl; + os << indent + 1; + printAll( withExprs, os, indent + 1 ); + } + if ( statements ) { os << indent << "... with body" << endl << indent+1; Index: src/SynTree/Type.cc =================================================================== --- src/SynTree/Type.cc (revision 46da46b804c2acd6916c888202a57186f41df8a8) +++ src/SynTree/Type.cc (revision 3a7aa94e697cfe6575ffbfec969567cc0eecc91f) @@ -16,4 +16,5 @@ #include "Attribute.h" // for Attribute +#include "Common/ToString.hpp" // for toCString #include "Common/utility.h" // for cloneAll, deleteAll, printAll #include "InitTweak/InitTweak.h" // for getPointerBase @@ -105,4 +106,8 @@ int Type::referenceDepth() const { return 0; } +AggregateDecl * Type::getAggr() const { + assertf( false, "Non-aggregate type: %s", toCString( this ) ); +} + TypeSubstitution Type::genericSubstitution() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); } Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 46da46b804c2acd6916c888202a57186f41df8a8) +++ src/SynTree/Type.h (revision 3a7aa94e697cfe6575ffbfec969567cc0eecc91f) @@ -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 : Sun Feb 19 22:37:10 2023 +// Update Count : 176 // @@ -23,5 +23,5 @@ #include "BaseSyntaxNode.h" // for BaseSyntaxNode -#include "Common/utility.h" // for operator+ +#include "Common/Iterate.hpp"// for operator+ #include "Mutator.h" // for Mutator #include "SynTree.h" // for AST nodes @@ -124,8 +124,8 @@ bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); } bool operator<=( Qualifiers other ) const { - return is_const <= other.is_const //Any non-const converts to const without cost - && is_volatile <= other.is_volatile //Any non-volatile converts to volatile without cost - && is_mutex >= other.is_mutex //Any mutex converts to non-mutex without cost - && is_atomic == other.is_atomic; //No conversion from atomic to non atomic is free + return is_const <= other.is_const // Any non-const converts to const without cost + && is_volatile <= other.is_volatile // Any non-volatile converts to volatile without cost + && is_mutex >= other.is_mutex // Any mutex converts to non-mutex without cost + && is_atomic == other.is_atomic; // No conversion from atomic to non atomic is free } bool operator<( Qualifiers other ) const { return *this != other && *this <= other; } @@ -185,12 +185,12 @@ virtual bool isComplete() const { return true; } - virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); } + virtual AggregateDecl * getAggr() const; 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,10 +266,9 @@ 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 void print( std::ostream & os, Indenter indent = {} ) const override; - bool isWholeNumber() const; + 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; }; @@ -280,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; } @@ -302,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; }; @@ -311,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; } @@ -334,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; }; @@ -349,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; }; @@ -358,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; @@ -376,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; }; @@ -406,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; }; @@ -415,5 +414,5 @@ class ReferenceToType : public Type { public: - std::list< Expression* > parameters; + std::list< Expression * > parameters; std::string name; bool hoistType; @@ -429,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; @@ -444,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 ) {} @@ -450,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) @@ -467,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; @@ -482,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 ) {} @@ -488,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; } @@ -505,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; @@ -520,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 ) {} @@ -526,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; @@ -533,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; @@ -557,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; @@ -570,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; } @@ -585,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: @@ -623,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; }; @@ -632,22 +631,22 @@ class TypeofType : public Type { public: - 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, + 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, 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; }; @@ -655,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; }; @@ -675,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(); @@ -686,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; } @@ -695,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; }; @@ -710,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; }; @@ -723,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; }; @@ -736,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; }; @@ -747,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; };