Changes in src/GenPoly/Box.cc [2efe4b8:982f95d]

File:

• src/GenPoly/Box.cc (modified) (5 diffs)

src/GenPoly/Box.cc

@@ -38 +38 @@
 #include "Lvalue.h"                      // for generalizedLvalue
 #include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
-#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
 #include "ScopedSet.h"                   // for ScopedSet, ScopedSet<>::iter...
@@ -184 +183 @@
                         /// change the type of generic aggregate members to char[]
                         void mutateMembers( AggregateDecl * aggrDecl );
+                        /// returns the calculated sizeof expression for ty, or nullptr for use C sizeof()
+                        Expression* genSizeof( Type* ty );
 
                         /// Enters a new scope for type-variables, adding the type variables from ty
@@ -383 +384 @@
                 unsigned long n_members = 0;
                 bool firstMember = true;
-                for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
+                for ( Declaration* member : structDecl->get_members() ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
@@ -590 +591 @@
                         // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
-                                ResolvExpr::EqvClass eqvClass;
                                 assert( env );
                                 if ( tyParm->second.isComplete ) {
@@ -1737 +1737 @@
                 }
 
+                Expression * PolyGenericCalculator::genSizeof( Type* ty ) {
+                        if ( ArrayType * aty = dynamic_cast<ArrayType *>(ty) ) {
+                                // generate calculated size for possibly generic array
+                                Expression * sizeofBase = genSizeof( aty->get_base() );
+                                if ( ! sizeofBase ) return nullptr;
+                                Expression * dim = aty->get_dimension();
+                                aty->set_dimension( nullptr );
+                                return makeOp( "?*?", sizeofBase, dim );
+                        } else if ( findGeneric( ty ) ) {
+                                // generate calculated size for generic type
+                                return new NameExpr( sizeofName( mangleType( ty ) ) );
+                        } else return nullptr;
+                }
+
                 Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
-                        if ( findGeneric( ty ) ) {
-                                return new NameExpr( sizeofName( mangleType( ty ) ) );
-                        }
-                        return sizeofExpr;
+                        Type *ty = sizeofExpr->get_isType() ? 
+                                sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
+                        
+                        Expression * gen = genSizeof( ty );
+                        return gen ? gen : sizeofExpr;
                 }