Changes in src/ResolvExpr/CurrentObject.cc [4b97770:c6747a1]

File:

• src/ResolvExpr/CurrentObject.cc (modified) (4 diffs)

src/ResolvExpr/CurrentObject.cc

@@ -38 +38 @@
 
 namespace ResolvExpr {
+        long long int getConstValue( ConstantExpr * constExpr ) {
+                if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {
+                        if ( basicType->isInteger() ) {
+                                return constExpr->get_constant()->get_ival();
+                        } else {
+                                assertf( false, "Non-integer constant expression in getConstValue %s", toString( constExpr ).c_str() ); // xxx - might be semantic error
+                        }
+                } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
+                        return 1;
+                } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) {
+                        return 0;
+                } else {
+                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
+                }
+        }
+
         template< typename AggrInst >
         TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
@@ -125 +141 @@
                         base = at->get_base();
                         memberIter = createMemberIterator( base );
-                        if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
                         setSize( at->get_dimension() );
                 }
@@ -136 +151 @@
                 void setSize( Expression * expr ) {
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                try {
-                                        size = constExpr->intValue();
-                                        PRINT( std::cerr << "array type with size: " << size << std::endl; )
-                                } catch ( SemanticError & ) {
-                                        throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr );
-                                }
+                                size = getConstValue( constExpr );
+                                PRINT( std::cerr << "array type with size: " << size << std::endl; )
                         }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast
-                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                if ( EnumInstType * inst = dynamic_cast< EnumInstType * > ( varExpr->result ) ) {
-                                        long long int value;
-                                        if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
-                                                size = value;
-                                        }
-                                }
                         } else {
                                 assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this
@@ -160 +164 @@
                         // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                try {
-                                        index = constExpr->intValue();
-                                } catch( SemanticError & ) {
-                                        throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
-                                }
+                                index = getConstValue( constExpr );
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 setPosition( castExpr->get_arg() );
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                EnumInstType * inst = dynamic_cast<EnumInstType *>( varExpr->get_result() );
-                                assertf( inst, "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
-                                long long int value;
-                                if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
-                                        index = value;
-                                }
+                                assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
+                                index = 0; // xxx - get actual value of enum constant
                         } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
                                 index = 0; // xxx - get actual sizeof/alignof value?