Changeset 0720e049 for src/SynTree/Type.h

Timestamp:

Aug 11, 2017, 10:33:37 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

54cd58b0

Parents:

3d4b23fa (diff), 59a75cb (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:/u/cforall/software/cfa/cfa-cc

File:

• src/SynTree/Type.h (modified) (23 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 : Thu Mar 23 16:16:36 2017
-// Update Count     : 149
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  9 14:25:00 2017
+// Update Count     : 152
 //
 
-#ifndef TYPE_H
-#define TYPE_H
+#pragma once
 
 #include "BaseSyntaxNode.h"
@@ -128 +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 );
@@ -146 +151 @@
         void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
 
-        typedef std::list<TypeDecl *> ForallList;
         ForallList& get_forall() { return forall; }
 
@@ -166 +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 emptyQualifiers;                                // 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 {
@@ -212 +214 @@
                 LongDoubleImaginary,
                 NUMBER_OF_BASIC_TYPES
-        };
+        } kind;
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
@@ -227 +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 * >() );
@@ -253 +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& );
@@ -283 +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& );
@@ -306 +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 );
@@ -337 +341 @@
   protected:
         virtual std::string typeString() const = 0;
-        std::list< Expression* > parameters;
-        std::string name;
-  private:
-        bool hoistType;
 };
 
@@ -346 +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 * >()  );
@@ -369 +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;
 };
 
@@ -378 +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 * >()  );
@@ -401 +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 * >()  );
@@ -424 +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;
 };
 
@@ -433 +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 );
@@ -446 +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;
 };
 
@@ -455 +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 * >()  );
@@ -473 +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& );
@@ -509 +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& );
@@ -529 +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 * >()  );
@@ -555 +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;
 };
 
@@ -601 +602 @@
 
 std::ostream & operator<<( std::ostream & out, const Type * type );
-
-#endif // TYPE_H
 
 // Local Variables: //