Changeset a436947

Timestamp:

Jun 7, 2016, 3:59:15 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

d0f8b19

Parents:

db175c8

Message:

change type of enumerator to EnumInstType?, allow casting between EnumInstType? and BasicType?, add common type code for EnumInstType? and BasicType?

Location:

src

Files:

• ResolvExpr/CommonType.cc (modified) (3 diffs)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (4 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/Attribute.h (modified) (1 diff)

src/ResolvExpr/CommonType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CommonType.cc -- 
+// CommonType.cc --
 //
 // Author           : Richard C. Bilson
@@ -134 +134 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
+                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
+                        // use signed int in lieu of the enum type
+                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
+                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+                        } // if
                 } // if
         }
@@ -183 +189 @@
         }
 
-        void CommonType::visit( EnumInstType *aggregateUseType ) {
+        void CommonType::visit( EnumInstType *enumInstType ) {
+                if ( dynamic_cast< BasicType * >( type2 ) ) {
+                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
+                        Type * temp = type2;
+                        type2 = enumInstType;
+                        temp->accept( *this );
+                        type2 = temp;
+                } // if
         }
 

src/ResolvExpr/ConversionCost.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ConversionCost.cc -- 
+// ConversionCost.cc --
 //
 // Author           : Richard C. Bilson
@@ -157 +157 @@
                                 cost = Cost( 0, 0, tableResult );
                         } // if
-                } // if
+                } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
+                        // xxx - not positive this is correct, but appears to allow casting int => enum
+                        cost = Cost( 1, 0, 0 );
+    } // if
         }
 

src/ResolvExpr/Resolver.cc

@@ -38 +38 @@
                 virtual void visit( ObjectDecl *functionDecl );
                 virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( EnumDecl * enumDecl );
 
                 virtual void visit( ArrayType * at );
@@ -66 +67 @@
                 Type *initContext;
                 Type *switchType;
+                bool inEnumDecl = false;
         };
 
@@ -178 +180 @@
                 Type *temp = initContext;
                 initContext = new_type;
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                        // enumerator initializers should not use the enum type to initialize, since
+                        // the enum type is still incomplete at this point. Use signed int instead.
+                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                }
                 SymTab::Indexer::visit( objectDecl );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                        // delete newly created signed int type
+                        delete initContext;
+                }
                 initContext = temp;
         }
@@ -216 +227 @@
                 SymTab::Indexer::visit( functionDecl );
                 functionReturn = oldFunctionReturn;
+        }
+
+        void Resolver::visit( EnumDecl * enumDecl ) {
+                // in case we decide to allow nested enums
+                bool oldInEnumDecl = inEnumDecl;
+                inEnumDecl = true;
+                SymTab::Indexer::visit( enumDecl );
+                inEnumDecl = oldInEnumDecl;
         }
 

src/SymTab/Validate.cc

@@ -279 +279 @@
         void Pass1::visit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
-
                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
                         assert( obj );
-                        // obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
-                        BasicType * enumType = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
-                        obj->set_type( enumType ) ;
+                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
                 } // for
                 Parent::visit( enumDecl );

src/SynTree/Attribute.h

@@ -20 +20 @@
 
 // GCC attribute
-// https://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html#Attribute-Syntax
+// https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Attribute-Syntax.html#Attribute-Syntax
 class Attribute {
   public: