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

File:

• src/ResolvExpr/CurrentObject.cc (modified) (9 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 ) {
@@ -62 +78 @@
                 virtual ~MemberIterator() {}
 
-                /// walks the current object using the given designators as a guide
                 virtual void setPosition( std::list< Expression * > & designators ) = 0;
-
-                /// retrieve the list of possible Type/Designaton pairs for the current position in the currect object
                 virtual std::list<InitAlternative> operator*() const = 0;
-
-                /// true if the iterator is not currently at the end
                 virtual operator bool() const = 0;
-
-                /// moves the iterator by one member in the current object
                 virtual MemberIterator & bigStep() = 0;
-
-                /// moves the iterator by one member in the current subobject
                 virtual MemberIterator & smallStep() = 0;
-
-                /// the type of the current object
                 virtual Type * getType() = 0;
-
-                /// the type of the current subobject
                 virtual Type * getNext() = 0;
 
-                /// printing for debug
                 virtual void print( std::ostream & out, Indenter indent ) const = 0;
 
-                /// helper for operator*; aggregates must add designator to each init alternative, but
-                /// adding designators in operator* creates duplicates.
                 virtual std::list<InitAlternative> first() const = 0; // should be protected
         };
@@ -139 +139 @@
                 ArrayIterator( ArrayType * at ) : array( at ) {
                         PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
-                        base = at->base;
+                        base = at->get_base();
                         memberIter = createMemberIterator( base );
-                        if ( at->isVarLen ) SemanticError( at, "VLA initialization does not support @=: " );
-                        setSize( at->dimension );
+                        setSize( at->get_dimension() );
                 }
 
@@ -150 +149 @@
 
         private:
-                void setSize( Expression * expr ) { // replace this logic with an eval call
-                        auto res = eval(expr);
-                        if (res.second) {
-                                size = res.first;
+                void setSize( Expression * expr ) {
+                        if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( 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 {
-                                SemanticError( expr->location, toString("Array designator must be a constant expression: ", expr) );
+                                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
                         }
                 }
@@ -163 +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( SemanticErrorException & ) {
-                                        SemanticError( expr, "Constant expression of non-integral type in array designator: " );
-                                }
+                                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?
@@ -357 +350 @@
                                 }
                         }
-                        if ( atbegin ) {
+                        // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction
+                        if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction
                                 // xxx - what about case of empty struct??
                                 // only add self if at the very beginning of the structure
@@ -391 +385 @@
                         return *this;
                 }
+                virtual std::list<InitAlternative> first() const { return std::list<InitAlternative>{}; }
         };
 
@@ -444 +439 @@
                                 return new UnionIterator( uit );
                         } else {
-                                assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() );
+                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
                                 return new SimpleIterator( type );
                         }
@@ -519 +514 @@
                 } // for
                 if ( desigAlts.size() > 1 ) {
-                        SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
+                        throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation );
                 } else if ( desigAlts.size() == 0 ) {
-                        SemanticError( designation, "No reasonable alternatives for designation: " );
+                        throw SemanticError( "No reasonable alternatives for designation: ", designation );
                 }
                 DesignatorChain & d = desigAlts.back();