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

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 ) {
@@ -141 +125 @@
                         base = at->get_base();
                         memberIter = createMemberIterator( base );
+                        if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
                         setSize( at->get_dimension() );
                 }
@@ -151 +136 @@
                 void setSize( Expression * expr ) {
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                size = getConstValue( constExpr );
-                                PRINT( std::cerr << "array type with size: " << size << std::endl; )
+                                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 );
+                                }
                         }       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
@@ -164 +160 @@
                         // 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 ) ) {
-                                index = getConstValue( constExpr );
+                                try {
+                                        index = constExpr->intValue();
+                                } catch( SemanticError & ) {
+                                        throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
+                                }
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 setPosition( castExpr->get_arg() );
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                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
+                                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;
+                                }
                         } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
                                 index = 0; // xxx - get actual sizeof/alignof value?