Changeset 65cdc1e for src/SynTree/Type.h

Timestamp:

Aug 9, 2017, 3:21:58 PM (7 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

0ec9229

Parents:

cbce272

Message:

Syntax Nodes give public access to the fields with effective public access.X

File:

• src/SynTree/Type.h (modified) (22 diffs)

src/SynTree/Type.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:53:29 2017
-// Update Count     : 151
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:25:00 2017
+// Update Count     : 152
 //
 
@@ -127 +127 @@
         }; // Qualifiers
 
+        typedef std::list<TypeDecl *> ForallList;
+
+        Qualifiers tq;
+        ForallList forall;
+        std::list< Attribute * > attributes;
+
         Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
         Type( const Type & other );
@@ -145 +151 @@
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
 
-        typedef std::list<TypeDecl *> ForallList;
         ForallList& get_forall() { return forall; }
 
@@ -165 +170 @@
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Qualifiers tq;
-        ForallList forall;
-        std::list< Attribute * > attributes;
-};
-
-extern Type::Qualifiers noQualifiers;                           // no qualifiers on constants
+};
+
+extern const Type::FuncSpecifiers noFuncSpecifiers;
+extern const Type::StorageClasses noStorageClasses;
+extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
 
 class VoidType : public Type {
@@ -211 +214 @@
                 LongDoubleImaginary,
                 NUMBER_OF_BASIC_TYPES
-        };
+        } kind;
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
@@ -226 +229 @@
 
         bool isInteger() const;
-  private:
-        Kind kind;
 };
 
 class PointerType : public Type {
   public:
+        Type *base;
+
+        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
+        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 * >() );
@@ -252 +260 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+class ArrayType : public Type {
+  public:
         Type *base;
-
-        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
         bool isVarLen;
         bool isStatic;
-};
-
-class ArrayType : public Type {
-  public:
+
         ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
@@ -282 +288 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        Type *base;
-        Expression *dimension;
-        bool isVarLen;
-        bool isStatic;
 };
 
 class FunctionType : public Type {
   public:
+        std::list<DeclarationWithType*> returnVals;
+        std::list<DeclarationWithType*> parameters;
+
+        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
+        // This could be because of
+        // - an ellipsis in a prototype declaration
+        // - an unprototyped declaration
+        bool isVarArgs;
+
         FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         FunctionType( const FunctionType& );
@@ -305 +315 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<DeclarationWithType*> returnVals;
-        std::list<DeclarationWithType*> parameters;
-
-        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
-        // This could be because of
-        // - an ellipsis in a prototype declaration
-        // - an unprototyped declaration
-        bool isVarArgs;
 };
 
 class ReferenceToType : public Type {
   public:
+        std::list< Expression* > parameters;
+        std::string name;
+        bool hoistType;
+
         ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
         ReferenceToType( const ReferenceToType & other );
@@ -336 +341 @@
   protected:
         virtual std::string typeString() const = 0;
-        std::list< Expression* > parameters;
-        std::string name;
-  private:
-        bool hoistType;
 };
 
@@ -345 +346 @@
         typedef ReferenceToType Parent;
   public:
+        // 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;
+
         StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
         StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -368 +373 @@
   private:
         virtual std::string typeString() const;
-
-        // 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;
 };
 
@@ -377 +378 @@
         typedef ReferenceToType Parent;
   public:
+        // 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;
+
         UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
         UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -400 +405 @@
   private:
         virtual std::string typeString() const;
-
+};
+
+class EnumInstType : public ReferenceToType {
+        typedef ReferenceToType Parent;
+  public:
         // 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;
-};
-
-class EnumInstType : public ReferenceToType {
-        typedef ReferenceToType Parent;
-  public:
+        EnumDecl *baseEnum = nullptr;
+
         EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
         EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -423 +428 @@
   private:
         virtual std::string typeString() const;
-
-        // 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
-        EnumDecl *baseEnum = nullptr;
 };
 
@@ -432 +433 @@
         typedef ReferenceToType Parent;
   public:
+        // this member is filled in by the validate pass, which instantiates the members of the correponding
+        // aggregate with the actual type parameters specified for this use of the context
+        std::list< Declaration* > members;
+
         TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
         TraitInstType( const TraitInstType & other );
@@ -445 +450 @@
   private:
         virtual std::string typeString() const;
-
-        // this member is filled in by the validate pass, which instantiates the members of the correponding
-        // aggregate with the actual type parameters specified for this use of the context
-        std::list< Declaration* > members;
 };
 
@@ -454 +455 @@
         typedef ReferenceToType Parent;
   public:
+        // 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;
+        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, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
@@ -472 +478 @@
   private:
         virtual std::string typeString() const;
-        // 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;
-        bool isFtype;
 };
 
 class TupleType : public Type {
   public:
+        std::list<Type *> types;
+        std::list<Declaration *> members;
+
         TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
@@ -508 +513 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::list<Type *> types;
-        std::list<Declaration *> members;
 };
 
 class TypeofType : public Type {
   public:
+        Expression *expr;
+
         TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeofType( const TypeofType& );
@@ -528 +532 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
+};
+
+class AttrType : public Type {
+  public:
+        std::string name;
         Expression *expr;
-};
-
-class AttrType : public Type {
-  public:
+        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 * >()  );
@@ -554 +561 @@
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
-  private:
-        std::string name;
-        Expression *expr;
-        Type *type;
-        bool isType;
 };