Changeset b6838214 for src/ResolvExpr/CurrentObject.cc

Timestamp:

Jan 23, 2018, 5:46:43 PM (8 years ago)

Author:

Alan Kennedy <afakenne@…>

Branches:

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

Children:

258e6ad5

Parents:

b158d8f (diff), 15d248e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

add context switch for ARM

File:

• src/ResolvExpr/CurrentObject.cc (modified) (8 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 ) {
@@ -78 +62 @@
                 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
         };
@@ -141 +141 @@
                         base = at->get_base();
                         memberIter = createMemberIterator( base );
+                        if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
                         setSize( at->get_dimension() );
                 }
@@ -151 +152 @@
                 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 +176 @@
                         // 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?
@@ -350 +370 @@
                                 }
                         }
-                        // 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
+                        if ( atbegin ) {
                                 // xxx - what about case of empty struct??
                                 // only add self if at the very beginning of the structure
@@ -385 +404 @@
                         return *this;
                 }
-                virtual std::list<InitAlternative> first() const { return std::list<InitAlternative>{}; }
         };
 
@@ -439 +457 @@
                                 return new UnionIterator( uit );
                         } else {
-                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
+                                assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() );
                                 return new SimpleIterator( type );
                         }