Changes in / [d61d034:42b739d7]

Files:

• src/CodeGen/CodeGenerator.cc (modified) (2 diffs)
• src/Parser/TypeData.cc (modified) (1 diff)
• src/SynTree/BasicType.cc (modified) (1 diff)
• src/SynTree/Type.h (modified) (1 diff)
• tests/enum_tests/.expect/pointerEnum.cfa (added)
• tests/enum_tests/.expect/qualifiedEnum.cfa (added)
• tests/enum_tests/.expect/typedIntEnum.txt (modified) (1 diff)
• tests/enum_tests/pointerEnum.cfa (modified) (1 diff)
• tests/enum_tests/typedIntEnum.cfa (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -273 +273 @@
         }
 
-        template<typename pass_type>
-        inline void genEnumInitializer( PassVisitor<pass_type> * visitor, Type * baseType, std::ostream & output,
-        Initializer * init, long long * cur_val, Options options) {
-                auto baseTypeAsBasic = baseType ? dynamic_cast<BasicType *>( baseType ) : nullptr;
-                if ( init ) { // If value has an explicit initiazatior 
-                        output << " = "; 
-                        output << "(" << genType(baseType, "", options) << ")";
-                        init->accept( *visitor );
-                        if ( baseTypeAsBasic && baseTypeAsBasic->isInteger() ) { // if it is an integral type and initilizer offered, 
-                        // need to update the cur_val
-                                Expression* expr = ((SingleInit *)(init))->value;
-                                while ( auto temp = dynamic_cast<CastExpr *>(expr) ) { // unwrap introduced cast
-                                        expr = temp->arg;
-                                }
-                                *cur_val = ((ConstantExpr *)expr)->constant.get_ival()+1;
-                        }
-                } else if ( baseTypeAsBasic && baseTypeAsBasic->isInteger() ) { // integral implicitly init to cur_val + 1
-                        output << " = " << "(" << genType(baseType, "", options) << ")";
-                        output << (*cur_val)++;
-                }
-        }
-
         void CodeGenerator::postvisit( EnumDecl * enumDecl ) {
                 extension( enumDecl );
                 std::list< Declaration* > &memb = enumDecl->get_members();
                 if (enumDecl->base && ! memb.empty()) {
-                        long long cur_val = 0;
+                        unsigned long long last_val = -1; // if the first enum value has no explicit initializer,
+                        // as other
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
                                 ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
@@ -305 +284 @@
                                 output << "static ";
                                 output << genType(enumDecl->base, mangleName( obj ), options);
-                                genEnumInitializer( visitor, enumDecl->base, output, obj->get_init(), &cur_val, options);
+                                output << " = ";
+                                output << "(" << genType(enumDecl->base, "", options) << ")";
+                                if ( (BasicType *)(enumDecl->base) && ((BasicType *)(enumDecl->base))->isWholeNumber() ) {
+                                        if ( obj->get_init() ) {
+                                                obj->get_init()->accept( *visitor );
+                                                Expression* expr = ((SingleInit *)(obj->init))->value;
+                                                while ( auto temp = dynamic_cast<CastExpr *>(expr) ) {
+                                                        expr = temp->arg;
+                                                }
+                                                last_val = ((ConstantExpr *)expr)->constant.get_ival();
+                                        } else {
+                                                output << ++last_val;
+                                        } // if
+                                } else {
+                                        if ( obj->get_init() ) {
+                                                obj->get_init()->accept( *visitor );
+                                        } else {
+                                                // Should not reach here!
+                                        }
+                                }
                                 output << ";" << endl;
                         } // for

src/Parser/TypeData.cc

@@ -933 +933 @@
                         member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
                 } else if ( !cur->initializer ) {
-                        if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isInteger())) {
+                        if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
                                 SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
                         }

src/SynTree/BasicType.cc

@@ -29 +29 @@
 }
 
+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;

src/SynTree/Type.h

@@ -271 +271 @@
         virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        bool isWholeNumber() const;
         bool isInteger() const;
 };

tests/enum_tests/.expect/typedIntEnum.txt

@@ -1 @@
-0=0
-1=1
-1000=1000
-1001=1001
-2000=2000
-2001=2001
-2002=2002
+0
+1
+1000
+1001
+2000
+2001
+2002

tests/enum_tests/pointerEnum.cfa

@@ -11 +11 @@
 int main() {
     E * v = First;
-    // sout | "v: " | e.x;
+    sout | "v: " | e.x;
 }

tests/enum_tests/typedIntEnum.cfa

@@ -12 +12 @@
 
 int main() {
-    printf("0=%d\n", zero);
-    printf("1=%d\n", one);
-    printf("1000=%d\n", thousand);
-    printf("1001=%d\n", thousand_one);
-    printf("2000=%d\n", two_thousand);
-    printf("2001=%d\n", two_thousand_one);
-    printf("2002=%d\n", two_thousand_two);
+    printf("%d\n", zero);
+    printf("%d\n", one);
+    printf("%d\n", thousand);
+    printf("%d\n", thousand_one);
+    printf("%d\n", two_thousand);
+    printf("%d\n", two_thousand_one);
+    printf("%d\n", two_thousand_two);
     return 0;
 }