Fix #153. Factor out common code in StructLiteralExp::to(Const)Elem.

gen/structs.cpp

@@ -298,6 +298,164 @@ Lpadding2:
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
+std::vector<llvm::Value*> DtoStructLiteralValues(const StructDeclaration* sd, const std::vector<llvm::Value*>& inits)
+{
+    // get arrays 
+    size_t nvars = sd->fields.dim;
+    VarDeclaration** vars = (VarDeclaration**)sd->fields.data;
+
+    assert(inits.size() == nvars);
+
+    // first locate all explicit initializers
+    std::vector<VarDeclaration*> explicitInits;
+    for (size_t i=0; i < nvars; i++)
+    {
+        if (inits[i])
+        {
+            explicitInits.push_back(vars[i]);
+        }
+    }
+
+    // vector of values to build aggregate from
+    std::vector<llvm::Value*> values;
+
+    // offset trackers
+    size_t lastoffset = 0;
+    size_t lastsize = 0;
+
+    // index of next explicit init
+    size_t exidx = 0;
+    // number of explicit inits
+    size_t nex = explicitInits.size();
+
+    // for through each field and build up the struct, padding with zeros
+    size_t i;
+    for (i=0; i<nvars; i++)
+    {
+        VarDeclaration* var = vars[i];
+
+        // get var info
+        size_t os = var->offset;
+        size_t sz = var->type->size();
+
+        // get next explicit
+        VarDeclaration* nextVar = NULL;
+        size_t nextOs = 0;
+        if (exidx < nex)
+        {
+            nextVar = explicitInits[exidx];
+            nextOs = nextVar->offset;
+        }
+        // none, rest is defaults
+        else
+        {
+            break;
+        }
+
+        // not explicit initializer, default initialize if there is room, otherwise skip
+        if (!inits[i])
+        {
+            // default init if there is room
+            // (past current offset) and (small enough to fit before next explicit)
+            if ((os >= lastoffset + lastsize) && (os+sz <= nextOs))
+            {
+                // add any 0 padding needed before this field
+                if (os > lastoffset + lastsize)
+                {
+                    //printf("1added %lu zeros\n", os - lastoffset - lastsize);
+                    addZeros(values, lastoffset + lastsize, os);
+                }
+
+                // get field default init
+                IrField* f = var->ir.irField;
+                assert(f);
+                if (!f->constInit)
+                    f->constInit = DtoConstInitializer(var->loc, var->type, var->init);
+
+                values.push_back(f->constInit);
+
+                lastoffset = os;
+                lastsize = sz;
+                //printf("added default: %s : %lu (%lu)\n", var->toChars(), os, sz);
+            }
+            // skip
+            continue;
+        }
+
+        assert(nextVar == var);
+
+        // add any 0 padding needed before this field
+        if (os > lastoffset + lastsize)
+        {
+            //printf("added %lu zeros\n", os - lastoffset - lastsize);
+            addZeros(values, lastoffset + lastsize, os);
+        }
+
+        // add the expression value
+        values.push_back(inits[i]);
+
+        // update offsets
+        lastoffset = os;
+        lastsize = sz;
+
+        // go to next explicit init
+        exidx++;
+
+        //printf("added field: %s : %lu (%lu)\n", var->toChars(), os, sz);
+    }
+
+    // fill out rest with default initializers
+    const LLType* structtype = DtoType(sd->type);
+    size_t structsize = getABITypeSize(structtype);
+
+    // FIXME: this could probably share some code with the above
+    if (structsize > lastoffset+lastsize)
+    {
+        for (/*continue from first loop*/; i < nvars; i++)
+        {
+            VarDeclaration* var = vars[i];
+
+            // get var info
+            size_t os = var->offset;
+            size_t sz = var->type->size();
+
+            // skip?
+            if (os < lastoffset + lastsize)
+                continue;
+
+            // add any 0 padding needed before this field
+            if (os > lastoffset + lastsize)
+            {
+                //printf("2added %lu zeros\n", os - lastoffset - lastsize);
+                addZeros(values, lastoffset + lastsize, os);
+            }
+
+            // get field default init
+            IrField* f = var->ir.irField;
+            assert(f);
+            if (!f->constInit)
+                f->constInit = DtoConstInitializer(var->loc, var->type, var->init);
+
+            values.push_back(f->constInit);
+
+            lastoffset = os;
+            lastsize = sz;
+            //printf("2added default: %s : %lu (%lu)\n", var->toChars(), os, sz);
+        }
+    }
+
+    // add any 0 padding needed at the end of the literal
+    if (structsize > lastoffset+lastsize)
+    {
+        //printf("3added %lu zeros\n", structsize - lastoffset - lastsize);
+        addZeros(values, lastoffset + lastsize, structsize);
+    }
+
+    return values;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
 LLValue* DtoIndexStruct(LLValue* src, StructDeclaration* sd, VarDeclaration* vd)
 {
     Logger::println("indexing struct field %s:", vd->toPrettyChars());