Changeset 62423350 for src/ResolvExpr/CurrentObject.cc

Timestamp:

Jun 29, 2017, 5:06:24 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

a12d5aa

Parents:

bb1cd95

Message:

Big push on designations and initialization: works with generic types, tuples, arrays, tests pass.
Refactor guard_value_impl.
Add list of declarations to TupleType?.

File:

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

src/ResolvExpr/CurrentObject.cc

@@ -22 +22 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Type.h"
+#include "SynTree/TypeSubstitution.h"
 
 #if 0
@@ -32 +33 @@
         long long int getConstValue( ConstantExpr * constExpr ) {
                 if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {
-                        if ( basicType->get_kind() == BasicType::Char || basicType->get_kind() == BasicType::SignedChar || basicType->get_kind() == BasicType::UnsignedChar ) {
-                                assertf( constExpr->get_constant()->get_value().size() == 3, "constant value with unusual length: %s", constExpr->get_constant()->get_value().c_str() );
-                                return constExpr->get_constant()->get_value()[1];
+                        if ( basicType->isInteger() ) {
+                                return constExpr->get_constant()->get_ival();
                         } else {
-                                return stoll( constExpr->get_constant()->get_value() );
-                        }
+                                assertf( false, "Non-integer constant expression in getConstValue", 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", constExpr->get_result() );
+                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
                 }
         }
@@ -56 +60 @@
         std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
                 return out << std::string(indent.indent, ' ');
+        }
+
+        template< typename AggrInst >
+        TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
+                assert( inst );
+                assert( inst->get_baseParameters() );
+                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
+                std::list< Expression * > typeSubs = inst->get_parameters();
+                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
+                return subs;
+        }
+
+        TypeSubstitution makeGenericSubstitution( Type * type ) {
+                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
+                        return makeGenericSubstitution( inst );
+                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
+                        return makeGenericSubstitution( inst );
+                } else {
+                        return TypeSubstitution();
+                }
         }
 
@@ -135 +159 @@
                 void setSize( Expression * expr ) {
                         if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                                size = getConstValue( constExpr ); // 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
+                                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() );
+                                setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast
                         } else {
-                                assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() );
+                                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
                         }
                 }
@@ -231 +255 @@
         class AggregateIterator : public MemberIterator {
         public:
-                typedef std::list<Declaration *>::iterator iterator;
-                const char * kind = ""; // for debug
-                ReferenceToType * inst = nullptr;
-                AggregateDecl * decl = nullptr;
+                typedef std::list<Declaration *> MemberList;
+                typedef MemberList::const_iterator iterator;
+                std::string kind = ""; // for debug
+                std::string name;
+                Type * inst = nullptr;
+                const MemberList & members;
                 iterator curMember;
-                bool atbegin = true; // false at first {small,big}Step -- this struct type is only added to the possibilities at the beginning
+                bool atbegin = true; // false at first {small,big}Step -- this aggr type is only added to the possibilities at the beginning
                 Type * curType = nullptr;
                 MemberIterator * memberIter = nullptr;
-
-                AggregateIterator( const char * kind, ReferenceToType * inst, AggregateDecl * decl ) : kind( kind ), inst( inst ), decl( decl ), curMember( decl->get_members().begin() ) {
+                mutable TypeSubstitution sub;
+
+                AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) {
                         init();
                 }
@@ -249 +276 @@
 
                 bool init() {
-                        PRINT( std::cerr << "--init()--" << std::endl; )
-                        if ( curMember != decl->get_members().end() ) {
+                        PRINT( std::cerr << "--init()--" << members.size() << std::endl; )
+                        if ( curMember != members.end() ) {
                                 if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( *curMember ) ) {
                                         PRINT( std::cerr << "incremented to field: " << field << std::endl; )
@@ -264 +291 @@
                         if (memberIter && *memberIter) {
                                 std::list<InitAlternative> ret = memberIter->first();
+                                PRINT( std::cerr << "sub: " << sub << std::endl; )
                                 for ( InitAlternative & alt : ret ) {
                                         PRINT( std::cerr << "iterating and adding designators" << std::endl; )
                                         alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+                                        // need to substitute for generic types, so that casts are to concrete types
+                                        PRINT( std::cerr << "  type is: " << alt.type; )
+                                        sub.apply( alt.type ); // also apply to designation??
+                                        PRINT( std::cerr << " ==> " << alt.type << std::endl; )
                                 }
                                 return ret;
@@ -276 +308 @@
                         if ( ! designators.empty() ) {
                                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( designators.front() ) ) {
-                                        for ( curMember = decl->get_members().begin(); curMember != decl->get_members().end(); ++curMember ) {
+                                        for ( curMember = members.begin(); curMember != members.end(); ++curMember ) {
                                                 if ( *curMember == varExpr->get_var() ) {
                                                         designators.pop_front();
@@ -282 +314 @@
                                                         memberIter = createMemberIterator( varExpr->get_result() );
                                                         curType = varExpr->get_result();
-                                                        atbegin = curMember == decl->get_members().begin() && designators.empty(); // xxx - is this right??
+                                                        atbegin = curMember == members.begin() && designators.empty(); // xxx - is this the right condition for atbegin??
                                                         memberIter->setPosition( designators );
                                                         return;
                                                 } // if
                                         } // for
-                                        assertf( false, "could not find member in %s: %s", kind, toString( varExpr ).c_str() );
+                                        assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
                                 } else {
-                                        assertf( false, "bad designator given to %s: %s", kind, toString( designators.front() ).c_str() );
+                                        assertf( false, "bad designator given to %s: %s", kind.c_str(), toString( designators.front() ).c_str() );
                                 } // if
                         } // if
@@ -336 +368 @@
 
                 virtual void print( std::ostream & out, Indenter indent ) const {
-                        out << kind << "(" << decl->get_name() << ")";
+                        out << kind << "(" << name << ")";
                         if ( memberIter ) {
                                 Indenter childIndent = indent+1;
@@ -347 +379 @@
         class UnionIterator : public AggregateIterator {
         public:
-                UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst, inst->get_baseUnion() ) {}
+                UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst->get_name(), inst, inst->get_baseUnion()->get_members() ) {}
 
                 virtual operator bool() const { return (memberIter && *memberIter); }
@@ -357 +389 @@
                         memberIter = nullptr;
                         curType = nullptr;
-                        curMember = decl->get_members().end();
+                        curMember = members.end();
                         return *this;
                 }
@@ -365 +397 @@
         class StructIterator : public AggregateIterator {
         public:
-                StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst, inst->get_baseStruct() ) {}
-
-                virtual operator bool() const { return curMember != decl->get_members().end() || (memberIter && *memberIter); }
+                StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst->get_name(), inst, inst->get_baseStruct()->get_members() ) {}
+
+                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
 
                 virtual MemberIterator & bigStep() {
@@ -375 +407 @@
                         memberIter = nullptr;
                         curType = nullptr;
-                        for ( ; curMember != decl->get_members().end(); ) {
+                        for ( ; curMember != members.end(); ) {
+                                ++curMember;
+                                if ( init() ) {
+                                        return *this;
+                                }
+                        }
+                        return *this;
+                }
+        };
+
+        class TupleIterator : public AggregateIterator {
+        public:
+                TupleIterator( TupleType * inst ) : AggregateIterator( "TupleIterator", toString("Tuple", inst->size()), inst, inst->get_members() ) {}
+
+                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
+
+                virtual MemberIterator & bigStep() {
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        delete memberIter;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        for ( ; curMember != members.end(); ) {
                                 ++curMember;
                                 if ( init() ) {
@@ -392 +446 @@
                                 return new UnionIterator( uit );
                         } else {
-                                assertf( false, "some other reftotype" );
+                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
+                                return new SimpleIterator( type );
                         }
                 } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         return new ArrayIterator( at );
+                } else if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) {
+                        return new TupleIterator( tt );
                 } else {
                         return new SimpleIterator( type );
@@ -494 +551 @@
                 Type * type = objStack.top()->getNext();
                 if ( type ) {
-                        // xxx - record types.front()?
                         objStack.push( createMemberIterator( type ) );
                 } else {
@@ -517 +573 @@
                 return **objStack.top();
         }
+
+        Type * CurrentObject::getCurrentType() {
+                PRINT( std::cerr << "____getting current type" << std::endl; )
+                assertf( ! objStack.empty(), "objstack empty in getCurrentType" );
+                return objStack.top()->getNext();
+        }
 } // namespace ResolvExpr