Changeset be8bd88 for src/Parser/ParseNode.h

Timestamp:

Mar 8, 2017, 3:22:50 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

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:

031a2c95, 0e7ea335

Parents:

87c3bef (diff), 6363ad1 (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:

• src/Parser/ParseNode.h (modified) (12 diffs)

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 15:22:10 2017
-// Update Count     : 662
+// Last Modified On : Tue Mar  7 08:10:53 2017
+// Update Count     : 726
 //
 
@@ -19 +19 @@
 #include <string>
 #include <list>
+#include <bitset>
 #include <iterator>
 #include <memory>
@@ -39 +40 @@
 //##############################################################################
 
-extern char* yyfilename;
+extern char * yyfilename;
 extern int yylineno;
 
@@ -122 +123 @@
         }
 
-        Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
+        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
   private:
         bool extension = false;
@@ -203 +204 @@
         // These must remain in the same order as the corresponding DeclarationNode names.
 
-        // enum StorageClass { Extern, Static, Auto, Register, NoStorageClass };
-        // enum FunctionSpec { Inline, Fortran, Noreturn, NoFunctionSpec };
-        // enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Threadlocal, Mutex, NoQualifier };
-
-        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
-        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
+        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass,
+                                                ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal };
+        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
+                                                 InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
+        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier };
         enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
         enum ComplexType { Complex, Imaginary, NoComplexType };
@@ -217 +217 @@
         enum BuiltinType { Valist, Zero, One, NoBuiltinType };
 
-        static const char * storageName[];
-        static const char * qualifierName[];
-        static const char * basicTypeName[];
-        static const char * complexTypeName[];
-        static const char * signednessName[];
-        static const char * lengthName[];
-        static const char * aggregateName[];
-        static const char * typeClassName[];
-        static const char * builtinTypeName[];
-
-        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
-        static DeclarationNode * newQualifier( Qualifier );
-        static DeclarationNode * newForall( DeclarationNode * );
+        static const char * storageClassNames[];
+        static const char * funcSpecifierNames[];
+        static const char * typeQualifierNames[];
+        static const char * basicTypeNames[];
+        static const char * complexTypeNames[];
+        static const char * signednessNames[];
+        static const char * lengthNames[];
+        static const char * aggregateNames[];
+        static const char * typeClassNames[];
+        static const char * builtinTypeNames[];
+
         static DeclarationNode * newStorageClass( StorageClass );
+        static DeclarationNode * newFuncSpecifier( FuncSpecifier );
+        static DeclarationNode * newTypeQualifier( TypeQualifier );
         static DeclarationNode * newBasicType( BasicType );
         static DeclarationNode * newComplexType( ComplexType );
-        static DeclarationNode * newSignedNess( Signedness sn );
-        static DeclarationNode * newLength( Length lnth );
+        static DeclarationNode * newSignedNess( Signedness );
+        static DeclarationNode * newLength( Length );
         static DeclarationNode * newBuiltinType( BuiltinType );
+        static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newFromTypedef( std::string * );
+        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
@@ -263 +265 @@
         DeclarationNode * addQualifiers( DeclarationNode * );
         void checkQualifiers( const TypeData *, const TypeData * );
-        void checkStorageClasses( DeclarationNode * );
-        DeclarationNode * copyStorageClasses( DeclarationNode * );
+        void checkSpecifiers( DeclarationNode * );
+        DeclarationNode * copySpecifiers( DeclarationNode * );
         DeclarationNode * addType( DeclarationNode * );
         DeclarationNode * addTypedef();
@@ -295 +297 @@
 
         Declaration * build() const;
-        ::Type * buildType() const;
+        Type * buildType() const;
 
         bool get_hasEllipsis() const;
@@ -301 +303 @@
         DeclarationNode * extractAggregate() const;
         bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
+        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
 
         bool get_extension() const { return extension; }
@@ -323 +325 @@
 
         TypeData * type;
-        StorageClass storageClass;
+
+        typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses;
+        StorageClasses storageClasses;
+        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
+
+        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers;
+        FuncSpecifiers funcSpecs;
+        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
+
         ExpressionNode * bitfieldWidth;
-        bool isInline, isNoreturn;
         std::unique_ptr<ExpressionNode> enumeratorValue;
         bool hasEllipsis;
@@ -342 +351 @@
 
 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
-        Type* ret = orig ? orig->buildType() : nullptr;
+        Type * ret = orig ? orig->buildType() : nullptr;
         delete orig;
         return ret;
@@ -357 +366 @@
 
         virtual StatementNode * clone() const final { assert( false ); return nullptr; }
-        Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
+        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
 
         virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {