Changeset 656

Timestamp:

07/02/07 18:05:45 (1 year ago)

Author:

Gregor

Message:

MERGE: DMD 1.014

Files:

• branches/dmdfe/aggregate.h (modified) (1 diff)
• branches/dmdfe/constfold.c (modified) (4 diffs)
• branches/dmdfe/delegatize.c (modified) (1 diff)
• branches/dmdfe/enum.c (modified) (1 diff)
• branches/dmdfe/enum.h (modified) (2 diffs)
• branches/dmdfe/expression.c (modified) (6 diffs)
• branches/dmdfe/expression.h (modified) (5 diffs)
• branches/dmdfe/idgen.c (modified) (1 diff)
• branches/dmdfe/inline.c (modified) (3 diffs)
• branches/dmdfe/interpret.c (modified) (11 diffs)
• branches/dmdfe/lexer.c (modified) (1 diff)
• branches/dmdfe/lexer.h (modified) (1 diff)
• branches/dmdfe/mars.c (modified) (1 diff)
• branches/dmdfe/mtype.c (modified) (5 diffs)
• branches/dmdfe/optimize.c (modified) (3 diffs)
• branches/dmdfe/struct.c (modified) (1 diff)
• branches/dmdfe/template.c (modified) (4 diffs)
• branches/dmdfe/tocsym.c (modified) (2 diffs)
• branches/dmdfe/todt.c (modified) (2 diffs)
• branches/dmdfe/toobj.c (modified) (1 diff)
• branches/dmdfe/typinf.c (modified) (2 diffs)

branches/dmdfe/aggregate.h

@@ -44 +44 @@
-    unsigned alignsize;     // size of struct for alignment purposes
-    unsigned structalign;   // struct member alignment in effect
+    int hasUnions;      // set if aggregate has overlapping fields
-    Array fields;       // VarDeclaration fields
-    unsigned sizeok;        // set when structsize contains valid data

branches/dmdfe/constfold.c

@@ -663 +663 @@
-    real_t r2;
-
+    //printf("Equal(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars());
+
-    assert(op == TOKequal || op == TOKnotequal);
-
@@ -693 +695 @@
-        Expression *ee2 = (Expression *)es2->elements->data[i];
-
+        Expression *v = Equal(TOKequal, Type::tint32, ee1, ee2);
+        if (v == EXP_CANT_INTERPRET)
+            return EXP_CANT_INTERPRET;
+        cmp = v->toInteger();
+        if (cmp == 0)
+            break;
+        }
+    }
+    }
+    else if (e1->op == TOKstructliteral && e2->op == TOKstructliteral)
+    {   StructLiteralExp *es1 = (StructLiteralExp *)e1;
+    StructLiteralExp *es2 = (StructLiteralExp *)e2;
+
+    if (es1->sd != es2->sd)
+        cmp = 0;
+    else if ((!es1->elements || !es1->elements->dim) &&
+        (!es2->elements || !es2->elements->dim))
+        cmp = 1;        // both arrays are empty
+    else if (!es1->elements || !es2->elements)
+        cmp = 0;
+    else if (es1->elements->dim != es2->elements->dim)
+        cmp = 0;
+    else
+    {
+        cmp = 1;
+        for (size_t i = 0; i < es1->elements->dim; i++)
+        {   Expression *ee1 = (Expression *)es1->elements->data[i];
+        Expression *ee2 = (Expression *)es2->elements->data[i];
+
+        if (ee1 == ee2)
+            continue;
+        if (!ee1 || !ee2)
+        {   cmp = 0;
+            break;
+        }
-        Expression *v = Equal(TOKequal, Type::tint32, ee1, ee2);
-        if (v == EXP_CANT_INTERPRET)
@@ -1036 +1073 @@
-    Loc loc = e1->loc;
-
-)\n", e1
+, e2 = %s)\n", e1->toChars(), e2
-    assert(e1->type);
-    if (e1->op == TOKstring && e2->op == TOKint64)
@@ -1384 +1421 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

branches/dmdfe/delegatize.c

@@ -185 +185 @@
-
-
+void StructLiteralExp::scanForNestedRef(Scope *sc)
+{
+    arrayExpressionScanForNestedRef(sc, elements);
+}
+
+
-void TupleExp::scanForNestedRef(Scope *sc)
-{

branches/dmdfe/enum.c

@@ -27 +27 @@
-    minval = 0;
-    defaultval = 0;
+    sinit = NULL;
-}
-

branches/dmdfe/enum.h

@@ -26 +26 @@
-#endif
-
+
-struct EnumDeclaration : ScopeDsymbol
-{
@@ -48 +49 @@
-
-    void toDebug();
+
+    Symbol *sinit;
+    Symbol *toInitializer();
-};
-

branches/dmdfe/expression.c

@@ -307 +307 @@
-    for (size_t i = 0; i < exps->dim; i++)
-    {   Expression *arg = (Expression *)exps->data[i];
+        if (!arg)
+        continue;
-
-        // Inline expand all the tuples
@@ -2642 +2644 @@
-    key->toMangleBuffer(buf);
-    value->toMangleBuffer(buf);
+    }
+}
+
+/************************ StructLiteralExp ************************************/
+
+// sd( e1, e2, e3, ... )
+
+StructLiteralExp::StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements)
+    : Expression(loc, TOKstructliteral, sizeof(StructLiteralExp))
+{
+    this->sd = sd;
+    this->elements = elements;
+    this->s = NULL;
+    this->soffset = 0;
+    this->fillHoles = 1;
+}
+
+Expression *StructLiteralExp::syntaxCopy()
+{
+    return new StructLiteralExp(loc, sd, arraySyntaxCopy(elements));
+}
+
+Expression *StructLiteralExp::semantic(Scope *sc)
+{   Expression *e;
+
+#if LOGSEMANTIC
+    printf("StructLiteralExp::semantic('%s')\n", toChars());
+#endif
+
+    // Run semantic() on each element
+    for (size_t i = 0; i < elements->dim; i++)
+    {   e = (Expression *)elements->data[i];
+    if (!e)
+        continue;
+    e = e->semantic(sc);
+    elements->data[i] = (void *)e;
+    }
+    expandTuples(elements);
+    size_t offset = 0;
+    for (size_t i = 0; i < elements->dim; i++)
+    {   e = (Expression *)elements->data[i];
+    if (!e)
+        continue;
+
+    if (!e->type)
+        error("%s has no value", e->toChars());
+    e = resolveProperties(sc, e);
+    if (i >= sd->fields.dim)
+    {   error("more initializers than fields of %s", sd->toChars());
+        break;
+    }
+    Dsymbol *s = (Dsymbol *)sd->fields.data[i];
+    VarDeclaration *v = s->isVarDeclaration();
+    assert(v);
+    if (v->offset < offset)
+        error("overlapping initialization for %s", v->toChars());
+    offset = v->offset + v->type->size();
+    e = e->implicitCastTo(sc, v->type);
+    elements->data[i] = (void *)e;
+    }
+
+    /* Fill out remainder of elements[] with default initializers for fields[]
+     */
+    for (size_t i = elements->dim; i < sd->fields.dim; i++)
+    {   Dsymbol *s = (Dsymbol *)sd->fields.data[i];
+    VarDeclaration *v = s->isVarDeclaration();
+    assert(v);
+
+    if (v->offset < offset)
+    {   e = NULL;
+        sd->hasUnions = 1;
+    }
+    else
+    {
+        if (v->init)
+        {   e = v->init->toExpression();
+        if (!e)
+            error("cannot make expression out of initializer for %s", v->toChars());
+        }
+        else
+        e = v->type->defaultInit();
+        offset = v->offset + v->type->size();
+    }
+    elements->push(e);
+    }
+
+    type = sd->type;
+    return this;
+}
+
+/**************************************
+ * Gets expression at offset of type.
+ * Returns NULL if not found.
+ */
+
+Expression *StructLiteralExp::getField(Type *type, unsigned offset)
+{   Expression *e = NULL;
+    int i = getFieldIndex(type, offset);
+
+    if (i != -1)
+    {   e = (Expression *)elements->data[i];
+    if (e)
+    {
+        e = e->copy();
+        e->type = type;
+    }
+    }
+    return e;
+}
+
+/************************************
+ * Get index of field.
+ * Returns -1 if not found. 
+ */
+
+int StructLiteralExp::getFieldIndex(Type *type, unsigned offset)
+{
+    /* Find which field offset is by looking at the field offsets
+     */
+    for (size_t i = 0; i < sd->fields.dim; i++)
+    {
+    Dsymbol *s = (Dsymbol *)sd->fields.data[i];
+    VarDeclaration *v = s->isVarDeclaration();
+    assert(v);
+
+    if (offset == v->offset &&
+        type->size() == v->type->size())
+    {   Expression *e = (Expression *)elements->data[i];
+        if (e)
+        {
+        return i;
+        }
+        break;
+    }
+    }
+    return -1;
+}
+
+
+
+int StructLiteralExp::checkSideEffect(int flag)
+{   int f = 0;
+
+    for (size_t i = 0; i < elements->dim; i++)
+    {   Expression *e = (Expression *)elements->data[i];
+    if (!e)
+        continue;
+
+    f |= e->checkSideEffect(2);
+    }
+    if (flag == 0 && f == 0)
+    Expression::checkSideEffect(0);
+    return f;
+}
+
+void StructLiteralExp::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
+    buf->writestring(sd->toChars());
+    buf->writeByte('(');
+    argsToCBuffer(buf, elements, hgs);
+    buf->writeByte(')');
+}
+
+void StructLiteralExp::toMangleBuffer(OutBuffer *buf)
+{
+    size_t dim = elements ? elements->dim : 0;
+    buf->printf("S%u", dim);
+    for (size_t i = 0; i < dim; i++)
+    {   Expression *e = (Expression *)elements->data[i];
+    if (e)
+        e->toMangleBuffer(buf);
+    else
+        buf->writeByte('v');    // 'v' for void
-    }
-}
@@ -4188 +4363 @@
-    if (e1->op != TOKstring)
-    {   error("argument to mixin must be a string, not (%s)", e1->toChars());
+    type = Type::terror;
-    return this;
-    }
@@ -5178 +5354 @@
-    {   AggregateDeclaration *ad;
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-    {
-        ad = ((TypeClass *)t1)->sym;
-        goto L1;
-    }
-    else if (t1->ty == Tstruct)
-    {
-        ad = ((TypeStruct *)t1)->sym;
-    L1:
-        // Rewrite as e1.call(arguments)
@@ -6374 +6557 @@
-    : BinExp(loc, TOKindex, sizeof(IndexExp), e1, e2)
-{
+    //printf("IndexExp::IndexExp('%s')\n", toChars());
-    lengthVar = NULL;
-    modifiable = 0; // assume it is an rvalue
@@ -6390 +6574 @@
-    if (type)
-    return this;
+    if (!e1->type)
+    e1 = e1->semantic(sc);
-    assert(e1->type);       // semantic() should already be run on it
-    e = this;

branches/dmdfe/expression.h

@@ -36 +36 @@
-struct Declaration;
-struct AggregateDeclaration;
+struct StructDeclaration;
-struct TemplateInstance;
-struct TemplateDeclaration;
@@ -42 +43 @@
-struct BinExp;
-struct InterState;
+struct Symbol;      // back end symbol
-
-enum TOK;
@@ -376 +378 @@
-};
-
+struct StructLiteralExp : Expression
+{
+    StructDeclaration *sd;      // which aggregate this is for
+    Expressions *elements;  // parallels sd->fields[] with
+                // NULL entries for fields to skip
+
+    Symbol *s;          // back end symbol to initialize with literal
+    size_t soffset;     // offset from start of s
+    int fillHoles;      // fill alignment 'holes' with zero
+
+    StructLiteralExp(Loc loc, StructDeclaration *sd, Expressions *elements);
+
+    Expression *syntaxCopy();
+    Expression *semantic(Scope *sc);
+    Expression *getField(Type *type, unsigned offset);
+    int getFieldIndex(Type *type, unsigned offset);
+    elem *toElem(IRState *irs);
+    int checkSideEffect(int flag);
+    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+    void toMangleBuffer(OutBuffer *buf);
+    void scanForNestedRef(Scope *sc);
+    Expression *optimize(int result);
+    Expression *interpret(InterState *istate);
+    dt_t **toDt(dt_t **pdt);
+
+    int inlineCost(InlineCostState *ics);
+    Expression *doInline(InlineDoState *ids);
+    Expression *inlineScan(InlineScanState *iss);
+};
+
-struct TypeDotIdExp : Expression
-{
@@ -768 +800 @@
-    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
-    Expression *optimize(int result);
+    Expression *interpret(InterState *istate);
-};
-
@@ -1253 +1286 @@
-Expression *Cast(Type *type, Type *to, Expression *e1);
-Expression *ArrayLength(Type *type, Expression *e1);
+Expression *Ptr(Type *type, Expression *e1);
-
-Expression *Add(Type *type, Expression *e1, Expression *e2);

branches/dmdfe/idgen.c

@@ -197 +197 @@
-    { "adReverse", "_adReverse" },
-
+    // For internal functions
+    { "aaLen", "_aaLen" },
+    { "aaKeys", "_aaKeys" },
+    { "aaValues", "_aaValues" },
+    { "aaRehash", "_aaRehash" },
+
-    // For pragma's
-    { "lib" },

branches/dmdfe/inline.c

@@ -187 +187 @@
-{
-    return 1 + arrayInlineCost(ics, keys) + arrayInlineCost(ics, values);
+}
+
+int StructLiteralExp::inlineCost(InlineCostState *ics)
+{
+    return 1 + arrayInlineCost(ics, elements);
-}
-
@@ -716 +721 @@
-
-
+Expression *StructLiteralExp::doInline(InlineDoState *ids)
+{
+    StructLiteralExp *ce;
+
+    ce = (StructLiteralExp *)copy();
+    ce->elements = arrayExpressiondoInline(elements, ids);
+    return ce;
+}
+
+
-Expression *ArrayExp::doInline(InlineDoState *ids)
-{
@@ -1116 +1131 @@
-    arrayInlineScan(iss, keys);
-    arrayInlineScan(iss, values);
+
+    return e;
+}
+
+
+Expression *StructLiteralExp::inlineScan(InlineScanState *iss)
+{   Expression *e = this;
+
+    //printf("StructLiteralExp::inlineScan()\n");
+    arrayInlineScan(iss, elements);
-
-    return e;

branches/dmdfe/interpret.c

@@ -44 +44 @@
-}
-
+Expression *interpret_aaLen(InterState *istate, Expressions *arguments);
+Expression *interpret_aaKeys(InterState *istate, Expressions *arguments);
+Expression *interpret_aaValues(InterState *istate, Expressions *arguments);
+
-/*************************************
- * Attempt to interpret a function given the arguments.
@@ -57 +61 @@
-    printf("cantInterpret = %d, semanticRun = %d\n", cantInterpret, semanticRun);
-#endif
+    if (global.errors)
+    return NULL;
+    if (ident == Id::aaLen)
+    return interpret_aaLen(istate, arguments);
+    else if (ident == Id::aaKeys)
+    return interpret_aaKeys(istate, arguments);
+    else if (ident == Id::aaValues)
+    return interpret_aaValues(istate, arguments);
+
-    if (cantInterpret || semanticRun == 1)
-    return NULL;
@@ -846 +859 @@
-}
-
-
-
-
-
-
+
+
-    Expression *e = EXP_CANT_INTERPRET;
-    VarDeclaration *v = var->isVarDeclaration();
-    if (v)
-    {
@@ -871 +880 @@
-    }
-    return e;
+}
+
+Expression *VarExp::interpret(InterState *istate)
+{
+#if LOG
+    printf("VarExp::interpret() %s\n", toChars());
+#endif
+    return getVarExp(istate, var->isVarDeclaration());
-}
-
@@ -1078 +1095 @@
-}
-
+Expression *StructLiteralExp::interpret(InterState *istate)
+{   Expressions *expsx = NULL;
+
+#if LOG
+    printf("StructLiteralExp::interpret() %s\n", toChars());
+#endif
+    /* We don't know how to deal with overlapping fields
+     */
+    if (sd->hasUnions)
+    return EXP_CANT_INTERPRET;
+
+    if (elements)
+    {
+    for (size_t i = 0; i < elements->dim; i++)
+    {   Expression *e = (Expression *)elements->data[i];
+        if (!e)
+        continue;
+
+        Expression *ex = e->interpret(istate);
+        if (ex == EXP_CANT_INTERPRET)
+        {   delete expsx;
+        return EXP_CANT_INTERPRET;
+        }
+
+        /* If any changes, do Copy On Write
+         */
+        if (ex != e)
+        {
+        if (!expsx)
+        {   expsx = new Expressions();
+            expsx->setDim(elements->dim);
+            for (size_t j = 0; j < i; j++)
+            {
+            expsx->data[j] = elements->data[j];
+            }
+        }
+        expsx->data[i] = (void *)ex;
+        }
+    }
+    }
+    if (elements && expsx)
+    {
+    expandTuples(expsx);
+    if (expsx->dim != elements->dim)
+    {   delete expsx;
+        return EXP_CANT_INTERPRET;
+    }
+    StructLiteralExp *se = new StructLiteralExp(loc, sd, expsx);
+    se->type = type;
+    return se;
+    }
+    return this;
+}
+
-Expression *UnaExp::interpretCommon(InterState *istate, Expression *(*fp)(Type *, Expression *))
-{   Expression *e;
@@ -1171 +1242 @@
-    if (e1 == EXP_CANT_INTERPRET)
-    goto Lcant;
-
+
+
+
+
-    goto Lcant;
-
@@ -1177 +1251 @@
-    if (e2 == EXP_CANT_INTERPRET)
-    goto Lcant;
-
+
+
+
+
-    goto Lcant;
-
@@ -1214 +1291 @@
-    if (e1 == EXP_CANT_INTERPRET)
-    return e1;
+    Expression *e2 = this->e2->interpret(istate);
+    if (e2 == EXP_CANT_INTERPRET)
+    return e2;
+
+    /* Assignment to variable of the form:
+     *  v = e2
+     */
-    if (e1->op == TOKvar)
-    {
@@ -1233 +1317 @@
-        return e;
-        }
-
+
+
+
+
-        if (e2 != EXP_CANT_INTERPRET)
-        {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-    return e;
@@ -1497 +1772 @@
-    goto Lcant;
-
-op == TOKstring || 
+e1->op == TOKstring || e1->
-    {
-    /* Set the $ variable
@@ -1631 +1906 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

branches/dmdfe/lexer.c

@@ -2731 +2731 @@
-    Token::tochars[TOKarrayliteral] = "arrayliteral";
-    Token::tochars[TOKassocarrayliteral] = "assocarrayliteral";
+    Token::tochars[TOKstructliteral]    = "structliteral";
-    Token::tochars[TOKstring]       = "string";
-    Token::tochars[TOKdsymbol]      = "symbol";

branches/dmdfe/lexer.h

@@ -68 +68 @@
-    TOKnewanonclass, TOKcomment,
-    TOKarrayliteral, TOKassocarrayliteral,
+    TOKstructliteral,
-
-    // Operators

branches/dmdfe/mars.c

@@ -56 +56 @@
-    copyright = "Copyright (c) 1999-2007 by Digital Mars";
-    written = "written by Walter Bright";
-3
+4
-    global.structalign = 8;
-

branches/dmdfe/mtype.c

@@ -2195 +2195 @@
-        // Convert to Tarray
-        key = key->next->arrayOf();
+#endif
-        break;
-#endif
-    case Tbit:
-    case Tbool:
@@ -2230 +2230 @@
-    Expressions *arguments;
-
-"_aaLen"
+Id::aaLen
-    ec = new VarExp(0, fd);
-    arguments = new Expressions();
@@ -2245 +2245 @@
-
-    assert(size);
-"_aaKeys"
+Id::aaKeys
-    ec = new VarExp(0, fd);
-    arguments = new Expressions();
@@ -2259 +2259 @@
-    Expressions *arguments;
-
-"_aaValues"
+Id::aaValues
-    ec = new VarExp(0, fd);
-    arguments = new Expressions();
@@ -2276 +2276 @@
-    Expressions *arguments;
-
-"_aaRehash"
+Id::aaRehash
-    ec = new VarExp(0, fd);
-    arguments = new Expressions();