Navigation

← Previous Changeset
Next Changeset →

Changeset 1587:def7a1d494fd

Timestamp:

11/06/09 17:58:01 (10 months ago)

Author:

Christian Kamm <kamm incasoftware de>

branch:

default

Message:

Merge DMD 1.051

Files:

dmd/aggregate.h (modified) (1 diff)
dmd/arrayop.c (modified) (4 diffs)
dmd/attrib.c (modified) (8 diffs)
dmd/attrib.h (modified) (1 diff)
dmd/cast.c (modified) (2 diffs)
dmd/class.c (modified) (14 diffs)
dmd/constfold.c (modified) (3 diffs)
dmd/declaration.c (modified) (11 diffs)
dmd/declaration.h (modified) (6 diffs)
dmd/doc.c (modified) (11 diffs)
dmd/dsymbol.c (modified) (10 diffs)
dmd/dsymbol.h (modified) (1 diff)
dmd/enum.h (modified) (1 diff)
dmd/expression.c (modified) (44 diffs)
dmd/expression.h (modified) (7 diffs)
dmd/func.c (modified) (20 diffs)
dmd/idgen.c (modified) (2 diffs)
dmd/import.c (modified) (2 diffs)
dmd/import.h (modified) (1 diff)
dmd/init.c (modified) (3 diffs)
dmd/inline.c (modified) (4 diffs)
dmd/interpret.c (modified) (13 diffs)
dmd/lexer.c (modified) (2 diffs)
dmd/lexer.h (modified) (1 diff)
dmd/mangle.c (modified) (1 diff)
dmd/mars.c (modified) (2 diffs)
dmd/mars.h (modified) (5 diffs)
dmd/module.c (modified) (4 diffs)
dmd/module.h (modified) (2 diffs)
dmd/mtype.c (modified) (13 diffs)
dmd/mtype.h (modified) (1 diff)
dmd/opover.c (modified) (7 diffs)
dmd/optimize.c (modified) (2 diffs)
dmd/parse.c (modified) (2 diffs)
dmd/root/async.c (modified) (1 diff)
dmd/root/man.c (modified) (1 diff)
dmd/root/root.c (modified) (1 diff)
dmd/scope.c (modified) (3 diffs)
dmd/scope.h (modified) (1 diff)
dmd/statement.c (modified) (21 diffs)
dmd/statement.h (modified) (6 diffs)
dmd/struct.c (modified) (2 diffs)
dmd/template.c (modified) (16 diffs)
dmd/template.h (modified) (3 diffs)
gen/classes.cpp (modified) (1 diff)
gen/main.cpp (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

dmd/aggregate.h

--- Revision 1530:05c235309d6f
+++ Revision 1587:def7a1d494fd
     class ConstantStruct;
     class GlobalVariable;
+}
 struct AggregateDeclaration : ScopeDsymbol
+{
     Type *type;
     unsigned storage_class;
     enum PROT protection;
     Type *handle;       // 'this' type
     unsigned structsize;    // size of struct
     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
                 // 0: no size
                 // 1: size is correct
                 // 2: cannot determine size; fwd referenced
     int isdeprecated;       // !=0 if deprecated
-    Scope *scope;       // !=NULL means context to use
     // Special member functions
     InvariantDeclaration *inv;      // invariant
     NewDeclaration *aggNew;     // allocator
     DeleteDeclaration *aggDelete;   // deallocator
+#if DMDV2
+    //CtorDeclaration *ctor;
+    Dsymbol *ctor;          // CtorDeclaration or TemplateDeclaration
+    CtorDeclaration *defaultCtor;   // default constructor
+    Dsymbol *aliasthis;         // forward unresolved lookups to aliasthis
+#endif
     FuncDeclarations dtors; // Array of destructors
     FuncDeclaration *dtor;  // aggregate destructor
 #ifdef IN_GCC
     Array methods;              // flat list of all methods for debug information
 #endif
     AggregateDeclaration(Loc loc, Identifier *id);
     void semantic2(Scope *sc);
     void semantic3(Scope *sc);
     void inlineScan();
     unsigned size(Loc loc);
     static void alignmember(unsigned salign, unsigned size, unsigned *poffset);
     Type *getType();
     void addField(Scope *sc, VarDeclaration *v);
     int isDeprecated();     // is aggregate deprecated?
     FuncDeclaration *buildDtor(Scope *sc);
     void emitComment(Scope *sc);
+    void toJsonBuffer(OutBuffer *buf);
     void toDocBuffer(OutBuffer *buf);
     // For access checking
     virtual PROT getAccess(Dsymbol *smember);   // determine access to smember
     int isFriendOf(AggregateDeclaration *cd);
     int hasPrivateAccess(Dsymbol *smember); // does smember have private access to members of this class?
     void accessCheck(Loc loc, Scope *sc, Dsymbol *smember);
     enum PROT prot();
 #if IN_DMD
     // Back end
     Symbol *stag;       // tag symbol for debug data
     Symbol *sinit;
     Symbol *toInitializer();
 #endif
     AggregateDeclaration *isAggregateDeclaration() { return this; }
 #if IN_LLVM

dmd/arrayop.c

--- Revision 1408:afecdb8ee962
+++ Revision 1587:def7a1d494fd
-// Copyright (c) 1999-2008 by Digital Mars
+// Copyright (c) 1999-2009 by Digital Mars
 // All Rights Reserved
 // written by Walter Bright
 // http://www.digitalmars.com
 // License for redistribution is by either the Artistic License
 // in artistic.txt, or the GNU General Public License in gnu.txt.
 // See the included readme.txt for details.
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
 #include "rmem.h"
 #include "stringtable.h"
 #include "expression.h"
 #include "statement.h"
 #include "mtype.h"
 #include "declaration.h"
 #include "scope.h"
 #include "id.h"
 #include "module.h"
 #include "init.h"
 /***********************************
  * Construct the array operation expression.
  */
 Expression *BinExp::arrayOp(Scope *sc)
+{
+    //printf("BinExp::arrayOp() %s\n", toChars());
+    if (type->toBasetype()->nextOf()->toBasetype()->ty == Tvoid)
+    {
+        error("Cannot perform array operations on void[] arrays");
+        return new ErrorExp();
+    }
     Expressions *arguments = new Expressions();
     /* The expression to generate an array operation for is mangled
      * into a name to use as the array operation function name.
      * Mangle in the operands and operators in RPN order, and type.
      */
     OutBuffer buf;
     buf.writestring("_array");
     buildArrayIdent(&buf, arguments);
     buf.writeByte('_');
     /* Append deco of array element type
      */
 #if DMDV2
     buf.writestring(type->toBasetype()->nextOf()->toBasetype()->mutableOf()->deco);
 #else
     buf.writestring(type->toBasetype()->nextOf()->toBasetype()->deco);
 #endif
     size_t namelen = buf.offset;
 …
         /* Construct the function
          */
         TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc);
         //printf("ftype: %s\n", ftype->toChars());
         fd = new FuncDeclaration(0, 0, Lexer::idPool(name), STCundefined, ftype);
         fd->fbody = fbody;
         fd->protection = PROTpublic;
         fd->linkage = LINKd;
         // special attention for array ops
         fd->isArrayOp = true;
         sc->module->importedFrom->members->push(fd);
         sc = sc->push();
         sc->parent = sc->module->importedFrom;
         sc->stc = 0;
         sc->linkage = LINKd;
         fd->semantic(sc);
+        fd->semantic2(sc);
+        fd->semantic3(sc);
         sc->pop();
 //     }
 //     else
 //     {   /* In library, refer to it.
 //          */
 //         // FIXME
 //         fd = FuncDeclaration::genCfunc(NULL, type, name);
 //     }
     sv->ptrvalue = fd;  // cache symbol in hash table
+    }
     /* Call the function fd(arguments)
      */
     Expression *ec = new VarExp(0, fd);
     Expression *e = new CallExp(loc, ec, arguments);
     e->type = type;
     return e;
+}
 /******************************************
  * Construct the identifier for the array operation function,
  * and build the argument list to pass to it.
  */
 void Expression::buildArrayIdent(OutBuffer *buf, Expressions *arguments)
+{
     buf->writestring("Exp");
     arguments->shift(this);
+}
+void CastExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments)
+{
+    Type *tb = type->toBasetype();
+    if (tb->ty == Tarray || tb->ty == Tsarray)
+    {
+    e1->buildArrayIdent(buf, arguments);
+    }
+    else
+    Expression::buildArrayIdent(buf, arguments);
+}
 void SliceExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments)
+{
     buf->writestring("Slice");
     arguments->shift(this);
+}
 void AssignExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments)
+{
     /* Evaluate assign expressions right to left
      */
     e2->buildArrayIdent(buf, arguments);
     e1->buildArrayIdent(buf, arguments);
     buf->writestring("Assign");
+}
 #define X(Str) \
 void Str##AssignExp::buildArrayIdent(OutBuffer *buf, Expressions *arguments) \
 {                           \
     /* Evaluate assign expressions right to left    \
      */                         \
 …
 X(Xor)
 X(And)
 X(Or)
 #undef X
 /******************************************
  * Construct the inner loop for the array operation function,
  * and build the parameter list.
  */
 Expression *Expression::buildArrayLoop(Arguments *fparams)
+{
     Identifier *id = Identifier::generateId("c", fparams->dim);
     Argument *param = new Argument(0, type, id, NULL);
     fparams->shift(param);
     Expression *e = new IdentifierExp(0, id);
     return e;
+}
+Expression *CastExp::buildArrayLoop(Arguments *fparams)
+{
+    Type *tb = type->toBasetype();
+    if (tb->ty == Tarray || tb->ty == Tsarray)
+    {
+    return e1->buildArrayLoop(fparams);
+    }
+    else
+    return Expression::buildArrayLoop(fparams);
+}
 Expression *SliceExp::buildArrayLoop(Arguments *fparams)
+{
     Identifier *id = Identifier::generateId("p", fparams->dim);
     Argument *param = new Argument(STCconst, type, id, NULL);
     fparams->shift(param);
     Expression *e = new IdentifierExp(0, id);
     Expressions *arguments = new Expressions();
     Expression *index = new IdentifierExp(0, Id::p);
     arguments->push(index);
     e = new ArrayExp(0, e, arguments);
     return e;
+}
 Expression *AssignExp::buildArrayLoop(Arguments *fparams)
+{
     /* Evaluate assign expressions right to left
      */
     Expression *ex2 = e2->buildArrayLoop(fparams);
+#if DMDV2
+    /* Need the cast because:
+     *   b = c + p[i];
+     * where b is a byte fails because (c + p[i]) is an int
+     * which cannot be implicitly cast to byte.
+     */
+    ex2 = new CastExp(0, ex2, e1->type->nextOf());
+#endif
     Expression *ex1 = e1->buildArrayLoop(fparams);
     Argument *param = (Argument *)fparams->data[0];
     param->storageClass = 0;
     Expression *e = new AssignExp(0, ex1, ex2);
     return e;
+}
 #define X(Str) \
 Expression *Str##AssignExp::buildArrayLoop(Arguments *fparams)  \
 {                               \
     /* Evaluate assign expressions right to left        \
      */                             \
     Expression *ex2 = e2->buildArrayLoop(fparams);      \
     Expression *ex1 = e1->buildArrayLoop(fparams);      \
     Argument *param = (Argument *)fparams->data[0];     \
     param->storageClass = 0;                    \
     Expression *e = new Str##AssignExp(0, ex1, ex2);        \
     return e;                           \
+}
 …
     /* Evaluate assign expressions left to right        \
      */                             \
     Expression *ex1 = e1->buildArrayLoop(fparams);      \
     Expression *ex2 = e2->buildArrayLoop(fparams);      \
     Expression *e = new Str##Exp(0, ex1, ex2);          \
     return e;                           \
+}
 X(Add)
 X(Min)
 X(Mul)
 X(Div)
 X(Mod)
 X(Xor)
 X(And)
 X(Or)
 #undef X
+/***********************************************
+ * Test if operand is a valid array op operand.
+ */
+int Expression::isArrayOperand()
+{
+    //printf("Expression::isArrayOperand() %s\n", toChars());
+    if (op == TOKslice)
+    return 1;
+    if (type->toBasetype()->ty == Tarray)
+    {
+    switch (op)
+    {
+        case TOKadd:
+        case TOKmin:
+        case TOKmul:
+        case TOKdiv:
+        case TOKmod:
+        case TOKxor:
+        case TOKand:
+        case TOKor:
+        case TOKneg:
+        case TOKtilde:
+        return 1;
+        default:
+        break;
+    }
+    }
+    return 0;
+}

dmd/attrib.c

--- Revision 1392:336faed34424
+++ Revision 1587:def7a1d494fd
 // See the included readme.txt for details.
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 #include "rmem.h"
 #include "init.h"
 #include "declaration.h"
 #include "attrib.h"
 #include "cond.h"
 #include "scope.h"
 #include "id.h"
 #include "expression.h"
 #include "dsymbol.h"
 #include "aggregate.h"
 #include "module.h"
 #include "parse.h"
 #include "template.h"
+#if TARGET_NET
+ #include "frontend.net/pragma.h"
+#endif
 #if IN_LLVM
 #include "../gen/enums.h"
 #include "llvm/Support/CommandLine.h"
 static llvm::cl::opt<bool> ignoreUnsupportedPragmas("ignore",
     llvm::cl::desc("Ignore unsupported pragmas"),
     llvm::cl::ZeroOrMore);
 #endif
 extern void obj_includelib(const char *name);
 #if IN_DMD
 void obj_startaddress(Symbol *s);
 #endif
 …
+}
 Array *AttribDeclaration::include(Scope *sc, ScopeDsymbol *sd)
+{
     return decl;
+}
 int AttribDeclaration::addMember(Scope *sc, ScopeDsymbol *sd, int memnum)
+{
     int m = 0;
     Array *d = include(sc, sd);
     if (d)
+    {
     for (unsigned i = 0; i < d->dim; i++)
     {   Dsymbol *s = (Dsymbol *)d->data[i];
         m |= s->addMember(sc, sd, m | memnum);
+    }
+    }
     return m;
+}
+void AttribDeclaration::setScopeNewSc(Scope *sc,
+    unsigned stc, enum LINK linkage, enum PROT protection, int explicitProtection,
+    unsigned structalign)
+{
+    if (decl)
+    {
+    Scope *newsc = sc;
+    if (stc != sc->stc ||
+        linkage != sc->linkage ||
+        protection != sc->protection ||
+        explicitProtection != sc->explicitProtection ||
+        structalign != sc->structalign)
+    {
+        // create new one for changes
+        newsc = new Scope(*sc);
+        newsc->flags &= ~SCOPEfree;
+        newsc->stc = stc;
+        newsc->linkage = linkage;
+        newsc->protection = protection;
+        newsc->explicitProtection = explicitProtection;
+        newsc->structalign = structalign;
+    }
+    for (unsigned i = 0; i < decl->dim; i++)
+    {   Dsymbol *s = (Dsymbol *)decl->data[i];
+        s->setScope(newsc); // yes, the only difference from semanticNewSc()
+    }
+    if (newsc != sc)
+    {
+        sc->offset = newsc->offset;
+        newsc->pop();
+    }
+    }
+}
+void AttribDeclaration::semanticNewSc(Scope *sc,
+    unsigned stc, enum LINK linkage, enum PROT protection, int explicitProtection,
+    unsigned structalign)
+{
+    if (decl)
+    {
+    Scope *newsc = sc;
+    if (stc != sc->stc ||
+        linkage != sc->linkage ||
+        protection != sc->protection ||
+        explicitProtection != sc->explicitProtection ||
+        structalign != sc->structalign)
+    {
+        // create new one for changes
+        newsc = new Scope(*sc);
+        newsc->flags &= ~SCOPEfree;
+        newsc->stc = stc;
+        newsc->linkage = linkage;
+        newsc->protection = protection;
+        newsc->explicitProtection = explicitProtection;
+        newsc->structalign = structalign;
+    }
+    for (unsigned i = 0; i < decl->dim; i++)
+    {   Dsymbol *s = (Dsymbol *)decl->data[i];
+        s->semantic(newsc);
+    }
+    if (newsc != sc)
+    {
+        sc->offset = newsc->offset;
+        newsc->pop();
+    }
+    }
+}
 void AttribDeclaration::semantic(Scope *sc)
+{
     Array *d = include(sc, NULL);
     //printf("\tAttribDeclaration::semantic '%s', d = %p\n",toChars(), d);
     if (d)
+    {
     for (unsigned i = 0; i < d->dim; i++)
+    {
         Dsymbol *s = (Dsymbol *)d->data[i];
         s->semantic(sc);
+    }
+    }
+}
 void AttribDeclaration::semantic2(Scope *sc)
+{
 …
     buf->writenl();
+}
 /************************* StorageClassDeclaration ****************************/
 StorageClassDeclaration::StorageClassDeclaration(unsigned stc, Array *decl)
     : AttribDeclaration(decl)
+{
     this->stc = stc;
+}
 Dsymbol *StorageClassDeclaration::syntaxCopy(Dsymbol *s)
+{
     StorageClassDeclaration *scd;
     assert(!s);
     scd = new StorageClassDeclaration(stc, Dsymbol::arraySyntaxCopy(decl));
     return scd;
+}
+void StorageClassDeclaration::setScope(Scope *sc)
+{
+    if (decl)
+    {
+    unsigned scstc = sc->stc;
+    /* These sets of storage classes are mutually exclusive,
+     * so choose the innermost or most recent one.
+     */
+    if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest))
+        scstc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest);
+    if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared))
+        scstc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared);
+    if (stc & (STCconst | STCimmutable | STCmanifest))
+        scstc &= ~(STCconst | STCimmutable | STCmanifest);
+    if (stc & (STCgshared | STCshared | STCtls))
+        scstc &= ~(STCgshared | STCshared | STCtls);
+    scstc |= stc;
+    setScopeNewSc(sc, scstc, sc->linkage, sc->protection, sc->explicitProtection, sc->structalign);
+    }
+}
 void StorageClassDeclaration::semantic(Scope *sc)
+{
     if (decl)
+    {   unsigned stc_save = sc->stc;
+    unsigned scstc = sc->stc;
+    if (stc & (STCauto | STCscope | STCstatic | STCextern))
-        sc->stc &= ~(STCauto | STCscope | STCstatic | STCextern);
+    /* These sets of storage classes are mutually exclusive,
-    sc->stc |= stc;
+     * so choose the innermost or most recent one.
-    for (unsigned i = 0; i < decl->dim; i++)
+     */
+    if (stc & (STCauto | STCscope | STCstatic | STCextern | STCmanifest))
-        Dsymbol *s = (Dsymbol *)decl->data[i];
+        scstc &= ~(STCauto | STCscope | STCstatic | STCextern | STCmanifest);
+    if (stc & (STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared))
-        s->semantic(sc);
+        scstc &= ~(STCauto | STCscope | STCstatic | STCtls | STCmanifest | STCgshared);
+    if (stc & (STCconst | STCimmutable | STCmanifest))
-    sc->stc = stc_save;
+        scstc &= ~(STCconst | STCimmutable | STCmanifest);
+    if (stc & (STCgshared | STCshared | STCtls))
-    else
+        scstc &= ~(STCgshared | STCshared | STCtls);
-    sc->stc = stc;
+    scstc |= stc;
+    semanticNewSc(sc, scstc, sc->linkage, sc->protection, sc->explicitProtection, sc->structalign);
+    }
+}
 void StorageClassDeclaration::stcToCBuffer(OutBuffer *buf, int stc)
+{
     struct SCstring
+    {
     int stc;
     enum TOK tok;
     };
     static SCstring table[] =
+    {
     { STCauto,         TOKauto },
     { STCscope,        TOKscope },
     { STCstatic,       TOKstatic },
     { STCextern,       TOKextern },
     { STCconst,        TOKconst },
-//  { STCinvariant,    TOKimmutable },
-//  { STCshared,       TOKshared },
     { STCfinal,        TOKfinal },
     { STCabstract,     TOKabstract },
     { STCsynchronized, TOKsynchronized },
     { STCdeprecated,   TOKdeprecated },
     { STCoverride,     TOKoverride },
-//  { STCnothrow,      TOKnothrow },
-//  { STCpure,         TOKpure },
-//  { STCref,          TOKref },
-//  { STCtls,          TOKtls },
     };
     for (int i = 0; i < sizeof(table)/sizeof(table[0]); i++)
+    {
     if (stc & table[i].stc)
+    {
         buf->writestring(Token::toChars(table[i].tok));
         buf->writeByte(' ');
+    }
+    }
+}
 void StorageClassDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
     stcToCBuffer(buf, stc);
     AttribDeclaration::toCBuffer(buf, hgs);
+}
 /********************************* LinkDeclaration ****************************/
 LinkDeclaration::LinkDeclaration(enum LINK p, Array *decl)
     : AttribDeclaration(decl)
+{
     //printf("LinkDeclaration(linkage = %d, decl = %p)\n", p, decl);
     linkage = p;
+}
 Dsymbol *LinkDeclaration::syntaxCopy(Dsymbol *s)
+{
     LinkDeclaration *ld;
     assert(!s);
     ld = new LinkDeclaration(linkage, Dsymbol::arraySyntaxCopy(decl));
     return ld;
+}
+void LinkDeclaration::setScope(Scope *sc)
+{
+    //printf("LinkDeclaration::setScope(linkage = %d, decl = %p)\n", linkage, decl);
+    if (decl)
+    {
+    setScopeNewSc(sc, sc->stc, linkage, sc->protection, sc->explicitProtection, sc->structalign);
+    }
+}
 void LinkDeclaration::semantic(Scope *sc)
+{
     //printf("LinkDeclaration::semantic(linkage = %d, decl = %p)\n", linkage, decl);
     if (decl)
+    {   enum LINK linkage_save = sc->linkage;
+    semanticNewSc(sc, sc->stc, linkage, sc->protection, sc->explicitProtection, sc->structalign);
+    sc->linkage = linkage;
+    for (unsigned i = 0; i < decl->dim; i++)
+        Dsymbol *s = (Dsymbol *)decl->data[i];
+        s->semantic(sc);
+    sc->linkage = linkage_save;
+    else
+    sc->linkage = linkage;
+    }
+}
 void LinkDeclaration::semantic3(Scope *sc)
+{
     //printf("LinkDeclaration::semantic3(linkage = %d, decl = %p)\n", linkage, decl);
     if (decl)
     {   enum LINK linkage_save = sc->linkage;
     sc->linkage = linkage;
     for (unsigned i = 0; i < decl->dim; i++)
+    {
         Dsymbol *s = (Dsymbol *)decl->data[i];
         s->semantic3(sc);
+    }
     sc->linkage = linkage_save;
+    }
     else
+    {
 …
+}
 /********************************* ProtDeclaration ****************************/
 ProtDeclaration::ProtDeclaration(enum PROT p, Array *decl)
     : AttribDeclaration(decl)
+{
     protection = p;
     //printf("decl = %p\n", decl);
+}
 Dsymbol *ProtDeclaration::syntaxCopy(Dsymbol *s)
+{
     ProtDeclaration *pd;
     assert(!s);
     pd = new ProtDeclaration(protection, Dsymbol::arraySyntaxCopy(decl));
     return pd;
+}
+void ProtDeclaration::setScope(Scope *sc)
+{
+    if (decl)
+    {
+    setScopeNewSc(sc, sc->stc, sc->linkage, protection, 1, sc->structalign);
+    }
+}
+void ProtDeclaration::importAll(Scope *sc)
+{
+    Scope *newsc = sc;
+    if (sc->protection != protection ||
+       sc->explicitProtection != 1)
+    {
+       // create new one for changes
+       newsc = new Scope(*sc);
+       newsc->flags &= ~SCOPEfree;
+       newsc->protection = protection;
+       newsc->explicitProtection = 1;
+    }
+    for (int i = 0; i < decl->dim; i++)
+    {
+       Dsymbol *s = (Dsymbol *)decl->data[i];
+       s->importAll(newsc);
+    }
+    if (newsc != sc)
+       newsc->pop();
+}
 void ProtDeclaration::semantic(Scope *sc)
+{
     if (decl)
+    {   enum PROT protection_save = sc->protection;
-    int explicitProtection_save = sc->explicitProtection;
+    semanticNewSc(sc, sc->stc, sc->linkage, protection, 1, sc->structalign);
+    }
+    sc->protection = protection;
+    sc->explicitProtection = 1;
-    for (unsigned i = 0; i < decl->dim; i++)
+void ProtDeclaration::protectionToCBuffer(OutBuffer *buf, enum PROT protection)
+{
-        Dsymbol *s = (Dsymbol *)decl->data[i];
+    const char *p;
+        s->semantic(sc);
+    sc->protection = protection_save;
+    sc->explicitProtection = explicitProtection_save;
+    else
+    {   sc->protection = protection;
+    sc->explicitProtection = 1;
+void ProtDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{   const char *p;
     switch (protection)
+    {
     case PROTprivate:   p = "private";      break;
     case PROTpackage:   p = "package";      break;
     case PROTprotected: p = "protected";    break;
     case PROTpublic:    p = "public";       break;
     case PROTexport:    p = "export";       break;
     default:
         assert(0);
         break;
+    }
     buf->writestring(p);
+    buf->writeByte(' ');
+}
+void ProtDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
+    protectionToCBuffer(buf, protection);
     AttribDeclaration::toCBuffer(buf, hgs);
+}
 /********************************* AlignDeclaration ****************************/
 AlignDeclaration::AlignDeclaration(Loc loc, unsigned sa, Array *decl)
     : AttribDeclaration(decl)
+{
     this->loc = loc;
     salign = sa;
+}
 Dsymbol *AlignDeclaration::syntaxCopy(Dsymbol *s)
+{
     AlignDeclaration *ad;
     assert(!s);
     ad = new AlignDeclaration(loc, salign, Dsymbol::arraySyntaxCopy(decl));
     return ad;
+}
+void AlignDeclaration::setScope(Scope *sc)
+{
+    //printf("\tAlignDeclaration::setScope '%s'\n",toChars());
+    if (decl)
+    {
+    setScopeNewSc(sc, sc->stc, sc->linkage, sc->protection, sc->explicitProtection, salign);
+    }
+}
 void AlignDeclaration::semantic(Scope *sc)
+{
 // LDC
 // we only support packed structs, as from the spec: align(1) struct Packed { ... }
 // other alignments are simply ignored. my tests show this is what llvm-gcc does too ...
+    {
-    //printf("\tAlignDeclaration::semantic '%s'\n",toChars());
+    semanticNewSc(sc, sc->stc, sc->linkage, sc->protection, sc->explicitProtection, salign);
+    if (decl)
+    {   unsigned salign_save = sc->structalign;
+    for (unsigned i = 0; i < decl->dim; i++)
+        Dsymbol *s = (Dsymbol *)decl->data[i];
+        if (s->isStructDeclaration() && salign == 1)
+            sc->structalign = salign;
+            s->semantic(sc);
+            sc->structalign = salign_save;
+        else
+            s->semantic(sc);
+    sc->structalign = salign_save;
+    else
+    assert(0 && "what kind of align use triggers this?");
+}
 void AlignDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
     buf->printf("align (%d)", salign);
     AttribDeclaration::toCBuffer(buf, hgs);
+}
 /********************************* AnonDeclaration ****************************/
 AnonDeclaration::AnonDeclaration(Loc loc, int isunion, Array *decl)
     : AttribDeclaration(decl)
+{
     this->loc = loc;
     this->isunion = isunion;
-    this->scope = NULL;
     this->sem = 0;
+}
 Dsymbol *AnonDeclaration::syntaxCopy(Dsymbol *s)
+{
     AnonDeclaration *ad;
     assert(!s);
     ad = new AnonDeclaration(loc, isunion, Dsymbol::arraySyntaxCopy(decl));
     return ad;
+}
 void AnonDeclaration::semantic(Scope *sc)
+{
     //printf("\tAnonDeclaration::semantic %s %p\n", isunion ? "union" : "struct", this);
     Scope *scx = NULL;
     if (scope)
     {   sc = scope;
     scx = scope;
 …
 PragmaDeclaration::PragmaDeclaration(Loc loc, Identifier *ident, Expressions *args, Array *decl)
     : AttribDeclaration(decl)
+{
     this->loc = loc;
     this->ident = ident;
     this->args = args;
+}
 Dsymbol *PragmaDeclaration::syntaxCopy(Dsymbol *s)
+{
     //printf("PragmaDeclaration::syntaxCopy(%s)\n", toChars());
     PragmaDeclaration *pd;
     assert(!s);
     pd = new PragmaDeclaration(loc, ident,
     Expression::arraySyntaxCopy(args), Dsymbol::arraySyntaxCopy(decl));
     return pd;
+}
+void PragmaDeclaration::setScope(Scope *sc)
+{
+#if TARGET_NET
+    if (ident == Lexer::idPool("assembly"))
+    {
+        if (!args || args->dim != 1)
+        {
+            error("pragma has invalid number of arguments");
+        }
+        else
+        {
+            Expression *e = (Expression *)args->data[0];
+            e = e->semantic(sc);
+            e = e->optimize(WANTvalue | WANTinterpret);
+            args->data[0] = (void *)e;
+            if (e->op != TOKstring)
+            {
+                error("string expected, not '%s'", e->toChars());
+            }
+            PragmaScope* pragma = new PragmaScope(this, sc->parent, static_cast<StringExp*>(e));
+            assert(sc);
+            pragma->setScope(sc);
+            //add to module members
+            assert(sc->module);
+            assert(sc->module->members);
+            sc->module->members->push(pragma);
+        }
+    }
+#endif // TARGET_NET
+}
 void PragmaDeclaration::semantic(Scope *sc)
 {   // Should be merged with PragmaStatement
 #if IN_LLVM
     int llvm_internal = 0;
     std::string arg1str;
 #endif
     //printf("\tPragmaDeclaration::semantic '%s'\n",toChars());
     if (ident == Id::msg)
+    {
     if (args)
+    {
         for (size_t i = 0; i < args->dim; i++)
+        {
         Expression *e = (Expression *)args->data[i];
         e = e->semantic(sc);
         e = e->optimize(WANTvalue | WANTinterpret);
         if (e->op == TOKstring)
+        {
             StringExp *se = (StringExp *)e;
-            fprintf(stdmsg, "%.*s", (int)se->len, (char*)se->string);
+            fprintf(stdmsg, "%.*s", (int)se->len, (char *)se->string);
+        }
         else
-            error("string expected for message, not '%s'", e->toChars());
+            fprintf(stdmsg, e->toChars());
+        }
         fprintf(stdmsg, "\n");
+    }
     goto Lnodecl;
+    }
     else if (ident == Id::lib)
+    {
     if (!args || args->dim != 1)
         error("string expected for library name");
     else
+    {
         Expression *e = (Expression *)args->data[0];
         e = e->semantic(sc);
         e = e->optimize(WANTvalue | WANTinterpret);
         args->data[0] = (void *)e;
         if (e->op != TOKstring)
         error("string expected for library name, not '%s'", e->toChars());
         else if (global.params.verbose)
+        {
 …
         if (! d->isFuncDeclaration() && ! d->isVarDeclaration())
             d = NULL;
+        }
         if (!d)
         error("first argument of GNU_asm must be a function or variable declaration");
         e = (Expression *)args->data[1];
         e = e->semantic(sc);
         e = e->optimize(WANTvalue);
         if (e->op == TOKstring && ((StringExp *)e)->sz == 1)
         s = ((StringExp *)e);
         else
         error("second argument of GNU_asm must be a char string");
         if (d && s)
         d->c_ident = Lexer::idPool((char*) s->string);
+    }
     goto Lnodecl;
+    }
 #endif
+#if TARGET_NET
+    else if (ident == Lexer::idPool("assembly"))
+    {
+        if (!args || args->dim != 1)
+            error("pragma has invalid number of arguments");
+        else
+        {
+            Expression *e = (Expression *)args->data[0];
+            e = e->semantic(sc);
+            e = e->optimize(WANTvalue | WANTinterpret);
+            args->data[0] = (void *)e;
+            if (e->op != TOKstring)
+            {
+                error("string expected, not '%s'", e->toChars());
+            }
+            PragmaScope* pragma = new PragmaScope(this, sc->parent, static_cast<StringExp*>(e));
+            decl = new Array;
+            decl->push(pragma);
+        }
+    }
+#endif // TARGET_NET
 // LDC
 #if IN_LLVM
     // pragma(intrinsic, "string") { funcdecl(s) }
     else if (ident == Id::intrinsic)
+    {
         Expression* expr = (Expression *)args->data[0];
         expr = expr->semantic(sc);
         if (!args || args->dim != 1 || !parseStringExp(expr, arg1str))
+        {
              error("requires exactly 1 string literal parameter");
              fatal();
+        }
         llvm_internal = LLVMintrinsic;
+    }
     // pragma(notypeinfo) { typedecl(s) }
     else if (ident == Id::no_typeinfo)
+    {
 …
     /* If generating doc comment, be careful because if we're inside
      * a template, then include(NULL, NULL) will fail.
      */
     Array *d = decl ? decl : elsedecl;
     for (unsigned i = 0; i < d->dim; i++)
     {   Dsymbol *s = (Dsymbol *)d->data[i];
         s->emitComment(sc);
+    }
+    }
+}
 // Decide if 'then' or 'else' code should be included
 Array *ConditionalDeclaration::include(Scope *sc, ScopeDsymbol *sd)
+{
     //printf("ConditionalDeclaration::include()\n");
     assert(condition);
     return condition->include(sc, sd) ? decl : elsedecl;
+}
+void ConditionalDeclaration::setScope(Scope *sc)
+{
+    Array *d = include(sc, NULL);
+    //printf("\tConditionalDeclaration::setScope '%s', d = %p\n",toChars(), d);
+    if (d)
+    {
+       for (unsigned i = 0; i < d->dim; i++)
+       {
+           Dsymbol *s = (Dsymbol *)d->data[i];
+           s->setScope(sc);
+       }
+    }
+}
+void ConditionalDeclaration::importAll(Scope *sc)
+{
+    Array *d = include(sc, NULL);
+    //printf("\tConditionalDeclaration::importAll '%s', d = %p\n",toChars(), d);
+    if (d)
+    {
+       for (unsigned i = 0; i < d->dim; i++)
+       {
+           Dsymbol *s = (Dsymbol *)d->data[i];
+           s->importAll(sc);
+       }
+    }
+}
 void ConditionalDeclaration::addComment(unsigned char *comment)
+{
     /* Because addComment is called by the parser, if we called
      * include() it would define a version before it was used.
      * But it's no problem to drill down to both decl and elsedecl,
      * so that's the workaround.
      */
     if (comment)
+    {
     Array *d = decl;
     for (int j = 0; j < 2; j++)
+    {
         if (d)
+        {
         for (unsigned i = 0; i < d->dim; i++)
         {   Dsymbol *s;
 …
      * in the same scope, such as:
+     *
      * template Foo(int i)
      * {
      *     const int j = i + 1;
      *     static if (j == 3)
      *         const int k;
      * }
      */
     this->sd = sd;
     int m = 0;
     if (memnum == 0)
     {   m = AttribDeclaration::addMember(sc, sd, memnum);
     addisdone = 1;
+    }
     return m;
+}
+void StaticIfDeclaration::importAll(Scope *sc)
+{
+    // do not evaluate condition before semantic pass
+}
+void StaticIfDeclaration::setScope(Scope *sc)
+{
+    // do not evaluate condition before semantic pass
+}
 void StaticIfDeclaration::semantic(Scope *sc)
+{
     Array *d = include(sc, sd);
     //printf("\tStaticIfDeclaration::semantic '%s', d = %p\n",toChars(), d);
     if (d)
+    {
     if (!addisdone)
     {   AttribDeclaration::addMember(sc, sd, 1);
         addisdone = 1;
+    }
     for (unsigned i = 0; i < d->dim; i++)
+    {
         Dsymbol *s = (Dsymbol *)d->data[i];
         s->semantic(sc);
+    }
+    }
+}

dmd/attrib.h

--- Revision 1228:79758fd2f48a
+++ Revision 1587:def7a1d494fd
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2007 by Digital Mars
+// Copyright (c) 1999-2009 by Digital Mars
 // All Rights Reserved
 // written by Walter Bright
 // http://www.digitalmars.com
 // License for redistribution is by either the Artistic License
 // in artistic.txt, or the GNU General Public License in gnu.txt.
 // See the included readme.txt for details.
 #ifndef DMD_ATTRIB_H
 #define DMD_ATTRIB_H
 #ifdef __DMC__
 #pragma once
 #endif /* __DMC__ */
 #include "dsymbol.h"
 struct Expression;
 struct Statement;
 struct LabelDsymbol;
 struct Initializer;
 struct Module;
 struct Condition;
 #ifdef _DH
 struct HdrGenState;
 #endif
 /**************************************************************/
 struct AttribDeclaration : Dsymbol
+{
     Array *decl;    // array of Dsymbol's
     AttribDeclaration(Array *decl);
     virtual Array *include(Scope *sc, ScopeDsymbol *s);
     int addMember(Scope *sc, ScopeDsymbol *s, int memnum);
+    void setScopeNewSc(Scope *sc,
+    unsigned newstc, enum LINK linkage, enum PROT protection, int explictProtection,
+    unsigned structalign);
+    void semanticNewSc(Scope *sc,
+    unsigned newstc, enum LINK linkage, enum PROT protection, int explictProtection,
+    unsigned structalign);
     void semantic(Scope *sc);
     void semantic2(Scope *sc);
     void semantic3(Scope *sc);
     void inlineScan();
     void addComment(unsigned char *comment);
     void emitComment(Scope *sc);
     const char *kind();
     int oneMember(Dsymbol **ps);
     int hasPointers();
     void checkCtorConstInit();
     void addLocalClass(ClassDeclarations *);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+    void toJsonBuffer(OutBuffer *buf);
     AttribDeclaration *isAttribDeclaration() { return this; }
 #if IN_DMD
     virtual void toObjFile(int multiobj);           // compile to .obj file
     int cvMember(unsigned char *p);
 #endif
 #if IN_LLVM
     virtual void codegen(Ir*);
 #endif
 };
 struct StorageClassDeclaration: AttribDeclaration
+{
     unsigned stc;
     StorageClassDeclaration(unsigned stc, Array *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
+    void setScope(Scope *sc);
     void semantic(Scope *sc);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
     static void stcToCBuffer(OutBuffer *buf, int stc);
 };
 struct LinkDeclaration : AttribDeclaration
+{
     enum LINK linkage;
     LinkDeclaration(enum LINK p, Array *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
+    void setScope(Scope *sc);
     void semantic(Scope *sc);
     void semantic3(Scope *sc);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
     char *toChars();
 };
 struct ProtDeclaration : AttribDeclaration
+{
     enum PROT protection;
     ProtDeclaration(enum PROT p, Array *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
-    void semantic(Scope *sc);
+    void importAll(Scope *sc);
-    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+    void setScope(Scope *sc);
+    void semantic(Scope *sc);
+    void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+    static void protectionToCBuffer(OutBuffer *buf, enum PROT protection);
 };
 struct AlignDeclaration : AttribDeclaration
+{
     unsigned salign;
     AlignDeclaration(Loc loc, unsigned sa, Array *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
+    void setScope(Scope *sc);
     void semantic(Scope *sc);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 };
 struct AnonDeclaration : AttribDeclaration
+{
     int isunion;
-    Scope *scope;       // !=NULL means context to use
     int sem;            // 1 if successful semantic()
     AnonDeclaration(Loc loc, int isunion, Array *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
     void semantic(Scope *sc);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
     const char *kind();
 };
 struct PragmaDeclaration : AttribDeclaration
+{
     Expressions *args;      // array of Expression's
     PragmaDeclaration(Loc loc, Identifier *ident, Expressions *args, Array *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
     void semantic(Scope *sc);
+    void setScope(Scope *sc);
     int oneMember(Dsymbol **ps);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
     const char *kind();
 #if IN_DMD
     void toObjFile(int multiobj);           // compile to .obj file
 #endif
 #if IN_LLVM
     void codegen(Ir*);
 #endif
 };
 struct ConditionalDeclaration : AttribDeclaration
+{
     Condition *condition;
     Array *elsedecl;    // array of Dsymbol's for else block
     ConditionalDeclaration(Condition *condition, Array *decl, Array *elsedecl);
     Dsymbol *syntaxCopy(Dsymbol *s);
     int oneMember(Dsymbol **ps);
     void emitComment(Scope *sc);
     Array *include(Scope *sc, ScopeDsymbol *s);
     void addComment(unsigned char *comment);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
+    void toJsonBuffer(OutBuffer *buf);
+    void importAll(Scope *sc);
+    void setScope(Scope *sc);
 };
 struct StaticIfDeclaration : ConditionalDeclaration
+{
     ScopeDsymbol *sd;
     int addisdone;
     StaticIfDeclaration(Condition *condition, Array *decl, Array *elsedecl);
     Dsymbol *syntaxCopy(Dsymbol *s);
     int addMember(Scope *sc, ScopeDsymbol *s, int memnum);
     void semantic(Scope *sc);
+    void importAll(Scope *sc);
+    void setScope(Scope *sc);
     const char *kind();
 };
 // Mixin declarations
 struct CompileDeclaration : AttribDeclaration
+{
     Expression *exp;
     ScopeDsymbol *sd;
     int compiled;
     CompileDeclaration(Loc loc, Expression *exp);
     Dsymbol *syntaxCopy(Dsymbol *s);
     int addMember(Scope *sc, ScopeDsymbol *sd, int memnum);
     void compileIt(Scope *sc);
     void semantic(Scope *sc);
     void toCBuffer(OutBuffer *buf, HdrGenState *hgs);
 };

dmd/cast.c

--- Revision 1367:8026319762be
+++ Revision 1587:def7a1d494fd
     e->values = (Expressions *)values->copy();
     assert(keys->dim == values->dim);
     for (size_t i = 0; i < keys->dim; i++)
     {   Expression *ex = (Expression *)values->data[i];
         ex = ex->castTo(sc, tb->nextOf());
         e->values->data[i] = (void *)ex;
         ex = (Expression *)keys->data[i];
         ex = ex->castTo(sc, ((TypeAArray *)tb)->index);
         e->keys->data[i] = (void *)ex;
+    }
     e->type = t;
     return e;
+    }
 L1:
     return e->Expression::castTo(sc, t);
+}
 Expression *SymOffExp::castTo(Scope *sc, Type *t)
+{
-    Type *tb;
 #if 0
     printf("SymOffExp::castTo(this=%s, type=%s, t=%s)\n",
     toChars(), type->toChars(), t->toChars());
 #endif
     Expression *e = this;
-    tb = t->toBasetype();
+    Type *tb = t->toBasetype();
-    type = type->toBasetype();
+    Type *typeb = type->toBasetype();
-    if (tb != type)
+    if (tb != typeb)
+    {
     // Look for pointers to functions where the functions are overloaded.
     FuncDeclaration *f;
-    if (type->ty == Tpointer && type->next->ty == Tfunction &&
+    if (typeb->ty == Tpointer && typeb->next->ty == Tfunction &&
         tb->ty == Tpointer && tb->next->ty == Tfunction)
+    {
         f = var->isFuncDeclaration();
         if (f)
+        {
         f = f->overloadExactMatch(tb->next, m);
         if (f)
+        {
-            e = new SymOffExp(loc, f, 0);
+#if DMDV2
-            e->type = t;
+            if (tb->ty == Tdelegate)
+            {
+            if (f->needThis() && hasThis(sc))
+            {
+                e = new DelegateExp(loc, new ThisExp(loc), f);
+                e = e->semantic(sc);
+            }
+            else if (f->isNested())
+            {
+                e = new DelegateExp(loc, new IntegerExp(0), f);
+                e = e->semantic(sc);
+            }
+            else if (f->needThis())
+            {   error("no 'this' to create delegate for %s", f->toChars());
+                e = new ErrorExp();
+            }
+            else
+            {   error("cannot cast from function pointer to delegate");
+                e = new ErrorExp();
+            }
+            }
+            else
+#endif
+            {
+            e = new SymOffExp(loc, f, 0);
+            e->type = t;
+            }
+#if DMDV2
+            f->tookAddressOf++;
+#endif
             return e;
+        }
+        }
+    }
     e = Expression::castTo(sc, t);
+    }
-    e->type = t;
+    else
+    {
+    e->type = t;
+    }
     return e;
+}
 Expression *DelegateExp::castTo(Scope *sc, Type *t)
+{
     Type *tb;
 #if 0
     printf("DelegateExp::castTo(this=%s, type=%s, t=%s)\n",
     toChars(), type->toChars(), t->toChars());
 #endif
     Expression *e = this;
     static char msg[] = "cannot form delegate due to covariant return type";
     tb = t->toBasetype();
     type = type->toBasetype();
     if (tb != type)
+    {
     // Look for delegates to functions where the functions are overloaded.
     FuncDeclaration *f;
 …
     else if (t1->ty == Tsarray && t2->ty == Tsarray &&
          e2->implicitConvTo(t1->nextOf()->arrayOf()))
+    {
      Lx1:
     t = t1->nextOf()->arrayOf();
     e1 = e1->castTo(sc, t);
     e2 = e2->castTo(sc, t);
+    }
     else if (t1->ty == Tsarray && t2->ty == Tsarray &&
          e1->implicitConvTo(t2->nextOf()->arrayOf()))
+    {
      Lx2:
     t = t2->nextOf()->arrayOf();
     e1 = e1->castTo(sc, t);
     e2 = e2->castTo(sc, t);
+    }
     else if (t1->isintegral() && t2->isintegral())
+    {
     assert(0);
+    }
-    else if (e1->op == TOKslice && t1->ty == Tarray &&
+    else if (e1->isArrayOperand() && t1->ty == Tarray &&
          e2->implicitConvTo(t1->nextOf()))
     {   // T[] op T
     e2 = e2->castTo(sc, t1->nextOf());
     t = t1->nextOf()->arrayOf();
+    }
-    else if (e2->op == TOKslice && t2->ty == Tarray &&
+    else if (e2->isArrayOperand() && t2->ty == Tarray &&
          e1->implicitConvTo(t2->nextOf()))
     {   // T op T[]
     e1 = e1->castTo(sc, t2->nextOf());
     t = t2->nextOf()->arrayOf();
     //printf("test %s\n", e->toChars());
     e1 = e1->optimize(WANTvalue);
     if (isCommutative() && e1->isConst())
     {   /* Swap operands to minimize number of functions generated
          */
         //printf("swap %s\n", e->toChars());
         Expression *tmp = e1;
         e1 = e2;
         e2 = tmp;
+    }
+    }
     else
+    {
      Lincompatible:
     incompatibleTypes();

dmd/class.c

Revision 1530:05c235309d6f		Revision 1587:def7a1d494fd
1		1
2	// Compiler implementation of the D programming language	2	// Compiler implementation of the D programming language
3	// Copyright (c) 1999-2008 by Digital Mars	3	// Copyright (c) 1999-2009 by Digital Mars
4	// All Rights Reserved	4	// All Rights Reserved
5	// written by Walter Bright	5	// written by Walter Bright
6	// http://www.digitalmars.com	6	// http://www.digitalmars.com
7	// License for redistribution is by either the Artistic License	7	// License for redistribution is by either the Artistic License
8	// in artistic.txt, or the GNU General Public License in gnu.txt.	8	// in artistic.txt, or the GNU General Public License in gnu.txt.
9	// See the included readme.txt for details.	9	// See the included readme.txt for details.
10		10
11	#include <stdio.h>	11	#include <stdio.h>
12	#include <stdlib.h>	12	#include <stdlib.h>
13	#include <assert.h>	13	#include <assert.h>
14		14
15	#include "root.h"	15	#include "root.h"
16	#include "rmem.h"	16	#include "rmem.h"
17		17
18	#include "enum.h"	18	#include "enum.h"
19	#include "init.h"	19	#include "init.h"
20	#include "attrib.h"	20	#include "attrib.h"
21	#include "declaration.h"	21	#include "declaration.h"
22	#include "aggregate.h"	22	#include "aggregate.h"
23	#include "id.h"	23	#include "id.h"
…		…
144	}	144	}
145		145
146	if (id == Id::TypeInfo_Tuple)	146	if (id == Id::TypeInfo_Tuple)
147	{ if (Type::typeinfotypelist)	147	{ if (Type::typeinfotypelist)
148	Type::typeinfotypelist->error("%s", msg);	148	Type::typeinfotypelist->error("%s", msg);
149	Type::typeinfotypelist = this;	149	Type::typeinfotypelist = this;
150	}	150	}
151		151
152	#if DMDV2	152	#if DMDV2
153	if (id == Id::TypeInfo_Const)	153	if (id == Id::TypeInfo_Const)
154	{ if (Type::typeinfoconst)	154	{ if (Type::typeinfoconst)
155	Type::typeinfoconst->error("%s", msg);	155	Type::typeinfoconst->error("%s", msg);
156	Type::typeinfoconst = this;	156	Type::typeinfoconst = this;
157	}	157	}
158		158
159	if (id == Id::TypeInfo_Invariant)	159	if (id == Id::TypeInfo_Invariant)
160	{ if (Type::typeinfoinvariant)	160	{ if (Type::typeinfoinvariant)
161	Type::typeinfoinvariant->error("%s", msg);	161	Type::typeinfoinvariant->error("%s", msg);
162	Type::typeinfoinvariant = this;	162	Type::typeinfoinvariant = this;
163	}	163	}
		164
		165	if (id == Id::TypeInfo_Shared)
		166	{ if (Type::typeinfoshared)
		167	Type::typeinfoshared->error("%s", msg);
		168	Type::typeinfoshared = this;
		169	}
164	#endif	170	#endif
165	}	171	}
166		172
167	if (id == Id::Object)	173	if (id == Id::Object)
168	{ if (object)	174	{ if (object)
169	object->error("%s", msg);	175	object->error("%s", msg);
170	object = this;	176	object = this;
171	}	177	}
172		178
173	if (id == Id::ClassInfo)	179	if (id == Id::ClassInfo)
174	{ if (classinfo)	180	{ if (classinfo)
175	classinfo->error("%s", msg);	181	classinfo->error("%s", msg);
176	classinfo = this;	182	classinfo = this;
177	}	183	}
178		184
179	if (id == Id::ModuleInfo)	185	if (id == Id::ModuleInfo)
180	{ if (Module::moduleinfo)	186	{ if (Module::moduleinfo)
181	Module::moduleinfo->error("%s", msg);	187	Module::moduleinfo->error("%s", msg);
182	Module::moduleinfo = this;	188	Module::moduleinfo = this;
183	}	189	}
…		…
209	BaseClass b = (BaseClass )this->baseclasses.data[i];	215	BaseClass b = (BaseClass )this->baseclasses.data[i];
210	BaseClass *b2 = new BaseClass(b->type->syntaxCopy(), b->protection);	216	BaseClass *b2 = new BaseClass(b->type->syntaxCopy(), b->protection);
211	cd->baseclasses.data[i] = b2;	217	cd->baseclasses.data[i] = b2;
212	}	218	}
213		219
214	ScopeDsymbol::syntaxCopy(cd);	220	ScopeDsymbol::syntaxCopy(cd);
215	return cd;	221	return cd;
216	}	222	}
217		223
218	void ClassDeclaration::semantic(Scope *sc)	224	void ClassDeclaration::semantic(Scope *sc)
219	{ int i;	225	{ int i;
220	unsigned offset;	226	unsigned offset;
221		227
222	//printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);	228	//printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
223	//printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");	229	//printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
224	//printf("sc->stc = %x\n", sc->stc);	230	//printf("sc->stc = %x\n", sc->stc);
225		231
226	//{ static int n; if (++n == 20) (char)0=0; }	232	//{ static int n; if (++n == 20) (char)0=0; }
227		233
228	if (!ident) // if anonymous class	234	if (!ident) // if anonymous class
229	{ char *id = "__anonclass";	235	{ const char *id = "__anonclass";
230		236
231	ident = Identifier::generateId(id);	237	ident = Identifier::generateId(id);
232	}	238	}
233		239
234	if (!sc~~ope~~)	240	if (!sc)
235	{	241	sc = scope;
236	if (!parent && sc->parent && !sc->parent->isModule())	242	if (!parent && sc->parent && !sc->parent->isModule())
237	parent = sc->parent;	243	parent = sc->parent;
238		244
239	type = type->semantic(loc, sc);	245	type = type->semantic(loc, sc);
240	~~handle = handle->semantic(loc, sc)~~;	246	handle = type;
241	}	247
242	if (!members) // if forward reference	248	if (!members) // if forward reference
243	{ //printf("\tclass '%s' is forward referenced\n", toChars());	249	{ //printf("\tclass '%s' is forward referenced\n", toChars());
244	return;	250	return;
245	}	251	}
246	if (symtab)	252	if (symtab)
247	{ if (!scope)	253	{ if (!scope)
248	{ //printf("\tsemantic for '%s' is already completed\n", toChars());	254	{ //printf("\tsemantic for '%s' is already completed\n", toChars());
249	return; // semantic() already completed	255	return; // semantic() already completed
250	}	256	}
251	}	257	}
252	else	258	else
253	symtab = new DsymbolTable();	259	symtab = new DsymbolTable();
254		260
255	Scope *scx = NULL;	261	Scope *scx = NULL;
256	if (scope)	262	if (scope)
257	{ sc = scope;	263	{ sc = scope;
258	scx = scope; // save so we don't make redundant copies	264	scx = scope; // save so we don't make redundant copies
259	scope = NULL;	265	scope = NULL;
260	}	266	}
261	#ifdef IN_GCC	267	#ifdef IN_GCC
…		…
312	// Deriving from deprecated class makes this one deprecated too	318	// Deriving from deprecated class makes this one deprecated too
313	isdeprecated = 1;	319	isdeprecated = 1;
314		320
315	tc->checkDeprecated(loc, sc);	321	tc->checkDeprecated(loc, sc);
316	}	322	}
317	}	323	}
318		324
319	if (tc->sym->isInterfaceDeclaration())	325	if (tc->sym->isInterfaceDeclaration())
320	;	326	;
321	else	327	else
322	{	328	{
323	for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)	329	for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)
324	{	330	{
325	if (cdb == this)	331	if (cdb == this)
326	{	332	{
327	error("circular inheritance");	333	error("circular inheritance");
328	baseclasses.remove(0);	334	baseclasses.remove(0);
329	goto L7;	335	goto L7;
330	}	336	}
331	}	337	}
		338	if (!tc->sym->symtab \|\| tc->sym->sizeok == 0)
		339	{ // Try to resolve forward reference
		340	if (sc->mustsemantic && tc->sym->scope)
		341	tc->sym->semantic(NULL);
		342	}
332	if (!tc->sym->symtab \|\| tc->sym->scope \|\| tc->sym->sizeok == 0)	343	if (!tc->sym->symtab \|\| tc->sym->scope \|\| tc->sym->sizeok == 0)
333	{	344	{
		345	//printf("%s: forward reference of base class %s\n", toChars(), tc->sym->toChars());
334	//error("forward reference of base class %s", baseClass->toChars());	346	//error("forward reference of base class %s", baseClass->toChars());
335	// Forward reference of base class, try again later	347	// Forward reference of base class, try again later
336	//printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());	348	//printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
337	scope = scx ? scx : new Scope(*sc);	349	scope = scx ? scx : new Scope(*sc);
338	scope->setNoFree();	350	scope->setNoFree();
		351	if (tc->sym->scope)
		352	tc->sym->scope->module->addDeferredSemantic(tc->sym);
339	scope->module->addDeferredSemantic(this);	353	scope->module->addDeferredSemantic(this);
340	return;	354	return;
341	}	355	}
342	else	356	else
343	{ baseClass = tc->sym;	357	{ baseClass = tc->sym;
344	b->base = baseClass;	358	b->base = baseClass;
345	}	359	}
346	L7: ;	360	L7: ;
347	}	361	}
348	}	362	}
349	}	363	}
350		364
351	// Treat the remaining entries in baseclasses as interfaces	365	// Treat the remaining entries in baseclasses as interfaces
352	// Check for errors, handle forward references	366	// Check for errors, handle forward references
353	for (i = (baseClass ? 1 : 0); i < baseclasses.dim; )	367	for (i = (baseClass ? 1 : 0); i < baseclasses.dim; )
354	{ TypeClass *tc;	368	{ TypeClass *tc;
355	BaseClass *b;	369	BaseClass *b;
356	Type *tb;	370	Type *tb;
357		371
358	b = (BaseClass *)baseclasses.data[i];	372	b = (BaseClass *)baseclasses.data[i];
…		…
372	{	386	{
373	if (tc->sym->isDeprecated())	387	if (tc->sym->isDeprecated())
374	{	388	{
375	if (!isDeprecated())	389	if (!isDeprecated())
376	{	390	{
377	// Deriving from deprecated class makes this one deprecated too	391	// Deriving from deprecated class makes this one deprecated too
378	isdeprecated = 1;	392	isdeprecated = 1;
379		393
380	tc->checkDeprecated(loc, sc);	394	tc->checkDeprecated(loc, sc);
381	}	395	}
382	}	396	}
383		397
384	// Check for duplicate interfaces	398	// Check for duplicate interfaces
385	for (size_t j = (baseClass ? 1 : 0); j < i; j++)	399	for (size_t j = (baseClass ? 1 : 0); j < i; j++)
386	{	400	{
387	BaseClass b2 = (BaseClass )baseclasses.data[j];	401	BaseClass b2 = (BaseClass )baseclasses.data[j];
388	if (b2->base == tc->sym)	402	if (b2->base == tc->sym)
389	error("inherits from duplicate interface %s", b2->base->toChars());	403	error("inherits from duplicate interface %s", b2->base->toChars());
390	}	404	}
391		405
		406	if (!tc->sym->symtab)
		407	{ // Try to resolve forward reference
		408	if (sc->mustsemantic && tc->sym->scope)
		409	tc->sym->semantic(NULL);
		410	}
		411
392	b->base = tc->sym;	412	b->base = tc->sym;
393	if (!b->base->symtab \|\| b->base->scope)	413	if (!b->base->symtab \|\| b->base->scope)
394	{	414	{
395	//error("forward reference of base class %s", baseClass->toChars());	415	//error("forward reference of base class %s", baseClass->toChars());
396	// Forward reference of base, try again later	416	// Forward reference of base, try again later
397	//printf("\ttry later, forward reference of base %s\n", baseClass->toChars());	417	//printf("\ttry later, forward reference of base %s\n", baseClass->toChars());
398	scope = scx ? scx : new Scope(*sc);	418	scope = scx ? scx : new Scope(*sc);
399	scope->setNoFree();	419	scope->setNoFree();
		420	if (tc->sym->scope)
		421	tc->sym->scope->module->addDeferredSemantic(tc->sym);
400	scope->module->addDeferredSemantic(this);	422	scope->module->addDeferredSemantic(this);
401	return;	423	return;
402	}	424	}
403	}	425	}
404	i++;	426	i++;
405	}	427	}
406		428
407		429
408	// If no base class, and this is not an Object, use Object as base class	430	// If no base class, and this is not an Object, use Object as base class
409	if (!baseClass && ident != Id::Object)	431	if (!baseClass && ident != Id::Object)
410	{	432	{
411	// BUG: what if Object is redefined in an inner scope?	433	// BUG: what if Object is redefined in an inner scope?
412	Type *tbase = new TypeIdentifier(0, Id::Object);	434	Type *tbase = new TypeIdentifier(0, Id::Object);
413	BaseClass *b;	435	BaseClass *b;
414	TypeClass *tc;	436	TypeClass *tc;
415	Type *bt;	437	Type *bt;
416		438
417	if (!object)	439	if (!object)
418	{	440	{
419	error("missing or corrupt object.d");	441	error("missing or corrupt object.d");
…		…
483	if (toParent2())	505	if (toParent2())
484	{	506	{
485	error("is nested within %s, but super class %s is nested within %s",	507	error("is nested within %s, but super class %s is nested within %s",
486	toParent2()->toChars(),	508	toParent2()->toChars(),
487	baseClass->toChars(),	509	baseClass->toChars(),
488	baseClass->toParent2()->toChars());	510	baseClass->toParent2()->toChars());
489	}	511	}
490	else	512	else
491	{	513	{
492	error("is not nested, but super class %s is nested within %s",	514	error("is not nested, but super class %s is nested within %s",
493	baseClass->toChars(),	515	baseClass->toChars(),
494	baseClass->toParent2()->toChars());	516	baseClass->toParent2()->toChars());
495	}	517	}
496	isnested = 0;	518	isnested = 0;
497	}	519	}
498	}	520	}
499	else if (!(storage_class & STCstatic))	521	else if (!(storage_class & STCstatic))
500	{ Dsymbol *s = toParent2();	522	{ Dsymbol *s = toParent2();
501	if (s)	523	if (s)
502	{	524	{
503	~~ClassDeclaration *c~~d = s->isClassDeclaration();	525	AggregateDeclaration *ad = s->isClassDeclaration();
504	FuncDeclaration *fd = s->isFuncDeclaration();	526	FuncDeclaration *fd = s->isFuncDeclaration();
505		527
506		528
507	if (cd \|\| fd)	529	if (ad \|\| fd)
508	{ isnested = 1;	530	{ isnested = 1;
509	Type *t;	531	Type *t;
510	if (cd)	532	if (ad)
511	t = ~~cd->typ~~e;	533	t = ad->handle;
512	else if (fd)	534	else if (fd)
513	{ AggregateDeclaration *ad = fd->isMember2();	535	{ AggregateDeclaration *ad = fd->isMember2();
514	if (ad)	536	if (ad)
515	t = ad->handle;	537	t = ad->handle;
516	else	538	else
517	{	539	{
518	t = new TypePointer(Type::tvoid);	540	t = new TypePointer(Type::tvoid);
519	t = t->semantic(0, sc);	541	t = t->semantic(0, sc);
520	}	542	}
521	}	543	}
522	else	544	else
523	assert(0);	545	assert(0);
524	assert(!vthis);	546	assert(!vthis);
525	vthis = new ThisDeclaration(loc, t);	547	vthis = new ThisDeclaration(loc, t);
526	members->push(vthis);	548	members->push(vthis);
527	}	549	}
528	}	550	}
529	}	551	}
530	}	552	}
531		553
…		…
547	#if _WIN32	569	#if _WIN32
548	sc->linkage = LINKwindows;	570	sc->linkage = LINKwindows;
549	#else	571	#else
550	/* This enables us to use COM objects under Linux and	572	/* This enables us to use COM objects under Linux and
551	* work with things like XPCOM	573	* work with things like XPCOM
552	*/	574	*/
553	sc->linkage = LINKc;	575	sc->linkage = LINKc;
554	#endif	576	#endif
555	}	577	}
556	sc->protection = PROTpublic;	578	sc->protection = PROTpublic;
557	sc->explicitProtection = 0;	579	sc->explicitProtection = 0;
558	sc->structalign = 8;	580	sc->structalign = 8;
559	structalign = sc->structalign;	581	structalign = sc->structalign;
560	if (baseClass)	582	if (baseClass)
561	{ sc->offset = baseClass->structsize;	583	{ sc->offset = baseClass->structsize;
562	alignsize = baseClass->alignsize;	584	alignsize = baseClass->alignsize;
563	// if (isnested)	585	// if (isnested)
564	// sc->offset += PTRSIZE; // room for uplevel context pointer	586	// sc->offset += PTRSIZE; // room for uplevel context pointer
565	}	587	}
566	else	588	else
567	{ sc->offset = PTRSIZE * 2; // allow room for ~~vptr[] and~~ monitor	589	{ sc->offset = PTRSIZE * 2; // allow room for __vptr and __monitor
568	alignsize = PTRSIZE;	590	alignsize = PTRSIZE;
569	}	591	}
570	structsize = sc->offset;	592	structsize = sc->offset;
571	Scope scsave = *sc;	593	Scope scsave = *sc;
572	int members_dim = members->dim;	594	int members_dim = members->dim;
573	sizeok = 0;	595	sizeok = 0;
574	for (i = 0; i < members_dim; i++)	596	for (i = 0; i < members_dim; i++)
575	{	597	{
576	Dsymbol s = (Dsymbol )members->data[i];	598	Dsymbol s = (Dsymbol )members->data[i];
577	s->semantic(sc);	599	s->semantic(sc);
578	}	600	}
579		601
580	if (sizeok == 2)	602	if (sizeok == 2)
581	{ // semantic() failed because of forward references.	603	{ // semantic() failed because of forward references.
582	// Unwind what we did, and defer it for later	604	// Unwind what we did, and defer it for later
583	fields.setDim(0);	605	fields.setDim(0);
584	structsize = 0;	606	structsize = 0;
585	alignsize = 0;	607	alignsize = 0;
586	structalign = 0;	608	structalign = 0;
587		609
…		…
686	}	708	}
687		709
688	void ClassDeclaration::toCBuffer(OutBuffer buf, HdrGenState hgs)	710	void ClassDeclaration::toCBuffer(OutBuffer buf, HdrGenState hgs)
689	{	711	{
690	if (!isAnonymous())	712	if (!isAnonymous())
691	{	713	{
692	buf->printf("%s ", kind());	714	buf->printf("%s ", kind());
693	buf->writestring(toChars());	715	buf->writestring(toChars());
694	if (baseclasses.dim)	716	if (baseclasses.dim)
695	buf->writestring(" : ");	717	buf->writestring(" : ");
696	}	718	}
697	for (int i = 0; i < baseclasses.dim; i++)	719	for (int i = 0; i < baseclasses.dim; i++)
698	{	720	{
699	BaseClass b = (BaseClass )baseclasses.data[i];	721	BaseClass b = (BaseClass )baseclasses.data[i];
700		722
701	if (i)	723	if (i)
702	buf->writeByte(',');	724	buf->writeByte(',');
703	//buf->writestring(b->base->ident->toChars());	725	//buf->writestring(b->base->ident->toChars());
704	b->type->toCBuffer(buf, NULL, hgs);	726	b->type->toCBuffer(buf, NULL, hgs);
705	}	727	}
706	buf->writenl();	728	if (members)
707	buf->writeByte('{');	729	{
708	buf->writenl();	730	buf->writenl();
709	for (int i = 0; i < members->dim; i++)	731	buf->writeByte('{');
710	{	732	buf->writenl();
711	Dsymbol s = (Dsymbol )members->data[i];	733	for (int i = 0; i < members->dim; i++)
712		734	{
713	buf->writestring(" ");	735	Dsymbol s = (Dsymbol )members->data[i];
714	s->toCBuffer(buf, hgs);	736
715	}	737	buf->writestring(" ");
716	buf->writestring("}");	738	s->toCBuffer(buf, hgs);
		739	}
		740	buf->writestring("}");
		741	}
		742	else
		743	buf->writeByte(';');
717	buf->writenl();	744	buf->writenl();
718	}	745	}
719		746
720	#if 0	747	#if 0
721	void ClassDeclaration::defineRef(Dsymbol *s)	748	void ClassDeclaration::defineRef(Dsymbol *s)
722	{	749	{
723	ClassDeclaration *cd;	750	ClassDeclaration *cd;
724		751
725	AggregateDeclaration::defineRef(s);	752	AggregateDeclaration::defineRef(s);
726	cd = s->isClassDeclaration();	753	cd = s->isClassDeclaration();
727	baseType = cd->baseType;	754	baseType = cd->baseType;
728	cd->baseType = NULL;	755	cd->baseType = NULL;
729	}	756	}
730	#endif	757	#endif
731		758
732	/*********************************************	759	/*********************************************
733	* Determine if 'this' is a base class of cd.	760	* Determine if 'this' is a base class of cd.
734	* This is used to detect circular inheritance only.	761	* This is used to detect circular inheritance only.
735	*/	762	*/
736		763
…		…
763	return 1;	790	return 1;
764		791
765	/* cd->baseClass might not be set if cd is forward referenced.	792	/* cd->baseClass might not be set if cd is forward referenced.
766	*/	793	*/
767	if (!cd->baseClass && cd->baseclasses.dim && !cd->isInterfaceDeclaration())	794	if (!cd->baseClass && cd->baseclasses.dim && !cd->isInterfaceDeclaration())
768	{	795	{
769	cd->error("base class is forward referenced by %s", toChars());	796	cd->error("base class is forward referenced by %s", toChars());
770	}	797	}
771		798
772	cd = cd->baseClass;	799	cd = cd->baseClass;
773	}	800	}
774	return 0;	801	return 0;
775	}	802	}
776		803
777	Dsymbol ClassDeclaration::search(Loc loc, Identifier ident, int flags)	804	Dsymbol ClassDeclaration::search(Loc loc, Identifier ident, int flags)
778	{	805	{
779	Dsymbol *s;	806	Dsymbol *s;
780		807	//printf("%s.ClassDeclaration::search('%s')\n", toChars(), ident->toChars());
781	//printf("%s.ClassDeclaration::search('%s')\n", toChars(), ident->toChars());	808
782	if (scope)	809	if (scope)
783	semantic(scope);	810	{ Scope *sc = scope;
		811	sc->mustsemantic++;
		812	semantic(sc);
		813	sc->mustsemantic--;
		814	}
784		815
785	if (!members \|\| !symtab \|\| scope)	816	if (!members \|\| !symtab \|\| scope)
786	{ error("is forward referenced when looking for '%s'", ident->toChars());	817	{
		818	error("is forward referenced when looking for '%s'", ident->toChars());
787	//(char)0=0;	819	//(char)0=0;
788	return NULL;	820	return NULL;
789	}	821	}
790		822
791	s = ScopeDsymbol::search(loc, ident, flags);	823	s = ScopeDsymbol::search(loc, ident, flags);
792	if (!s)	824	if (!s)
793	{	825	{
794	// Search bases classes in depth-first, left to right order	826	// Search bases classes in depth-first, left to right order
795		827
796	int i;	828	int i;
797		829
798	for (i = 0; i < baseclasses.dim; i++)	830	for (i = 0; i < baseclasses.dim; i++)
799	{	831	{
800	BaseClass b = (BaseClass )baseclasses.data[i];	832	BaseClass b = (BaseClass )baseclasses.data[i];
801		833
802	if (b->base)	834	if (b->base)
803	{	835	{
804	if (!b->base->symtab)	836	if (!b->base->symtab)
805	error("base %s is forward referenced", b->base->ident->toChars());	837	error("base %s is forward referenced", b->base->ident->toChars());
806	else	838	else
…		…
814	}	846	}
815	}	847	}
816	}	848	}
817	return s;	849	return s;
818	}	850	}
819		851
820	/**********************************************************	852	/**********************************************************
821	* fd is in the vtbl[] for this class.	853	* fd is in the vtbl[] for this class.
822	* Return 1 if function is hidden (not findable through search).	854	* Return 1 if function is hidden (not findable through search).
823	*/	855	*/
824		856
825	#if DMDV2	857	#if DMDV2
826	int isf(void param, FuncDeclaration fd)	858	int isf(void param, FuncDeclaration fd)
827	{	859	{
828	//printf("param = %p, fd = %p %s\n", param, fd, fd->toChars());	860	//printf("param = %p, fd = %p %s\n", param, fd, fd->toChars());
829	return param == fd;	861	return param == fd;
830	}	862	}
831		863
832	int ClassDeclaration::isFuncHidden(FuncDeclaration *fd)	864	int ClassDeclaration::isFuncHidden(FuncDeclaration *fd)
833	{	865	{
834	//printf("ClassDeclaration::isFuncHidden(~~%s)\n"~~, fd->toChars());	866	//printf("ClassDeclaration::isFuncHidden(class = %s, fd = %s)\n", toChars(), fd->toChars());
835	Dsymbol *s = search(0, fd->ident, 4\|2);	867	Dsymbol *s = search(0, fd->ident, 4\|2);
836	if (!s)	868	if (!s)
837	{ //printf("not found\n");	869	{ //printf("not found\n");
838	/* Because, due to a hack, if there are multiple definitions	870	/* Because, due to a hack, if there are multiple definitions
839	* of fd->ident, NULL is returned.	871	* of fd->ident, NULL is returned.
840	*/	872	*/
841	return 0;	873	return 0;
842	}	874	}
843	FuncDeclaration *fdstart = s->toAlias()->isFuncDeclaration();	875	FuncDeclaration *fdstart = s->toAlias()->isFuncDeclaration();
844	//printf("%s fdstart = %p\n", s->kind(), fdstart);	876	//printf("%s fdstart = %p\n", s->kind(), fdstart);
845	return !overloadApply(getModule(), fdstart, &isf, fd);	877	return !overloadApply(getModule(), fdstart, &isf, fd);
846	}	878	}
847	#endif	879	#endif
848		880
849	/****************	881	/****************
850	* Find virtual function matching identifier and type.	882	* Find virtual function matching identifier and type.
851	* Used to build virtual function tables for interface implementations.	883	* Used to build virtual function tables for interface implementations.
852	*/	884	*/
853		885
854	FuncDeclaration ClassDeclaration::findFunc(Identifier ident, TypeFunction *tf)	886	FuncDeclaration ClassDeclaration::findFunc(Identifier ident, TypeFunction *tf)
…		…
899	com = 1;	931	com = 1;
900		932
901	vtblInterfaces->push(b);	933	vtblInterfaces->push(b);
902	b->copyBaseInterfaces(vtblInterfaces);	934	b->copyBaseInterfaces(vtblInterfaces);
903	}	935	}
904	}	936	}
905		937
906	/****************************************	938	/****************************************
907	*/	939	*/
908		940
909	int ClassDeclaration::isCOMclass()	941	int ClassDeclaration::isCOMclass()
910	{	942	{
911	return com;	943	return com;
912	}	944	}
913		945
914	int ClassDeclaration::isCOMinterface()	946	int ClassDeclaration::isCOMinterface()
915	{	947	{
916	return 0;	948	return 0;
917	}	949	}
918		950
		951	#if DMDV2
		952	int ClassDeclaration::isCPPinterface()
		953	{
		954	return 0;
		955	}
		956	#endif
		957
919		958
920	/****************************************	959	/****************************************
921	*/	960	*/
922		961
923	int ClassDeclaration::isAbstract()	962	int ClassDeclaration::isAbstract()
924	{	963	{
925	if (isabstract)	964	if (isabstract)
926	return TRUE;	965	return TRUE;
927	for (int i = 1; i < vtbl.dim; i++)	966	for (int i = 1; i < vtbl.dim; i++)
928	{	967	{
929	FuncDeclaration fd = ((Dsymbol )vtbl.data[i])->isFuncDeclaration();	968	FuncDeclaration fd = ((Dsymbol )vtbl.data[i])->isFuncDeclaration();
930		969
931	//printf("\tvtbl[%d] = %p\n", i, fd);	970	//printf("\tvtbl[%d] = %p\n", i, fd);
932	if (!fd \|\| fd->isAbstract())	971	if (!fd \|\| fd->isAbstract())
933	{	972	{
934	isabstract \|= 1;	973	isabstract \|= 1;
935	return TRUE;	974	return TRUE;
936	}	975	}
937	}	976	}
938	return FALSE;	977	return FALSE;
…		…
989		1028
990	Dsymbol InterfaceDeclaration::syntaxCopy(Dsymbol s)	1029	Dsymbol InterfaceDeclaration::syntaxCopy(Dsymbol s)
991	{	1030	{
992	InterfaceDeclaration *id;	1031	InterfaceDeclaration *id;
993		1032
994	if (s)	1033	if (s)
995	id = (InterfaceDeclaration *)s;	1034	id = (InterfaceDeclaration *)s;
996	else	1035	else
997	id = new InterfaceDeclaration(loc, ident, NULL);	1036	id = new InterfaceDeclaration(loc, ident, NULL);
998		1037
999	ClassDeclaration::syntaxCopy(id);	1038	ClassDeclaration::syntaxCopy(id);
1000	return id;	1039	return id;
1001	}	1040	}
1002		1041
1003	void InterfaceDeclaration::semantic(Scope *sc)	1042	void InterfaceDeclaration::semantic(Scope *sc)
1004	{ int i;	1043	{ int i;
1005		1044
1006	//printf("InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type);	1045	//printf("InterfaceDeclaration::semantic(%s), type = %p\n", toChars(), type);
1007	if (inuse)	1046	if (inuse)
1008	return;	1047	return;
1009	if (!scope)	1048
1010	{ type = type->semantic(loc, sc);	1049	if (!sc)
1011	handle = handle->semantic(loc, sc);	1050	sc = scope;
1012	}	1051	if (!parent && sc->parent && !sc->parent->isModule())
		1052	parent = sc->parent;
		1053
		1054	type = type->semantic(loc, sc);
		1055	handle = type;
		1056
1013	if (!members) // if forward reference	1057	if (!members) // if forward reference
1014	{ //printf("\tinterface '%s' is forward referenced\n", toChars());	1058	{ //printf("\tinterface '%s' is forward referenced\n", toChars());
1015	return;	1059	return;
1016	}	1060	}
1017	if (symtab) // if already done	1061	if (symtab) // if already done
1018	{ if (!scope)	1062	{ if (!scope)
1019	return;	1063	return;
1020	}	1064	}
1021	else	1065	else
1022	symtab = new DsymbolTable();	1066	symtab = new DsymbolTable();
1023		1067
1024	Scope *scx = NULL;	1068	Scope *scx = NULL;
1025	if (scope)	1069	if (scope)
1026	{ sc = scope;	1070	{ sc = scope;
1027	scx = scope; // save so we don't make redundant copies	1071	scx = scope; // save so we don't make redundant copies
1028	scope = NULL;	1072	scope = NULL;
1029	}	1073	}
1030		1074
1031	if (sc->stc & STCdeprecated)	1075	if (sc->stc & STCdeprecated)
1032	{	1076	{
…		…
1072	error("base type must be interface, not %s", b->type->toChars());	1116	error("base type must be interface, not %s", b->type->toChars());
1073	baseclasses.remove(i);	1117	baseclasses.remove(i);
1074	continue;	1118	continue;
1075	}	1119	}
1076	else	1120	else
1077	{	1121	{
1078	// Check for duplicate interfaces	1122	// Check for duplicate interfaces
1079	for (size_t j = 0; j < i; j++)	1123	for (size_t j = 0; j < i; j++)
1080	{	1124	{
1081	BaseClass b2 = (BaseClass )baseclasses.data[j];	1125	BaseClass b2 = (BaseClass )baseclasses.data[j];
1082	if (b2->base == tc->sym)	1126	if (b2->base == tc->sym)
1083	error("inherits from duplicate interface %s", b2->base->toChars());	1127	error("inherits from duplicate interface %s", b2->base->toChars());
1084	}	1128	}
1085		1129
1086	b->base = tc->sym;	1130	b->base = tc->sym;
1087	if (b->base == this \|\| isBaseOf2(b->base))	1131	if (b->base == this \|\| isBaseOf2(b->base))
1088	{	1132	{
1089	error("circular inheritance of interface");	1133	error("circular inheritance of interface");
1090	baseclasses.remove(i);	1134	baseclasses.remove(i);
1091	continue;	1135	continue;
		1136	}
		1137	if (!b->base->symtab)
		1138	{ // Try to resolve forward reference
		1139	if (sc->mustsemantic && b->base->scope)
		1140	b->base->semantic(NULL);
1092	}	1141	}
1093	if (!b->base->symtab \|\| b->base->scope \|\| b->base->inuse)	1142	if (!b->base->symtab \|\| b->base->scope \|\| b->base->inuse)
1094	{	1143	{
1095	//error("forward reference of base class %s", baseClass->toChars());	1144	//error("forward reference of base class %s", baseClass->toChars());
1096	// Forward reference of base, try again later	1145	// Forward reference of base, try again later
1097	//printf("\ttry later, forward reference of base %s\n", b->base->toChars());	1146	//printf("\ttry later, forward reference of base %s\n", b->base->toChars());
1098	scope = scx ? scx : new Scope(*sc);	1147	scope = scx ? scx : new Scope(*sc);
1099	scope->setNoFree();	1148	scope->setNoFree();
1100	scope->module->addDeferredSemantic(this);	1149	scope->module->addDeferredSemantic(this);
1101	return;	1150	return;
1102	}	1151	}
1103	}	1152	}
1104	i++;	1153	i++;
1105	}	1154	}
1106		1155
1107	interfaces_dim = baseclasses.dim;	1156	interfaces_dim = baseclasses.dim;
1108	interfaces = (BaseClass **)baseclasses.data;	1157	interfaces = (BaseClass **)baseclasses.data;
1109		1158
1110	interfaceSemantic(sc);	1159	interfaceSemantic(sc);
1111		1160
…		…
1245		1294
1246	/****************************************	1295	/****************************************
1247	* Determine if slot 0 of the vtbl[] is reserved for something else.	1296	* Determine if slot 0 of the vtbl[] is reserved for something else.
1248	* For class objects, yes, this is where the ClassInfo ptr goes.	1297	* For class objects, yes, this is where the ClassInfo ptr goes.
1249	* For COM interfaces, no.	1298	* For COM interfaces, no.
1250	* For non-COM interfaces, yes, this is where the Interface ptr goes.	1299	* For non-COM interfaces, yes, this is where the Interface ptr goes.
1251	*/	1300	*/
1252		1301
1253	int InterfaceDeclaration::vtblOffset()	1302	int InterfaceDeclaration::vtblOffset()
1254	{	1303	{
1255	if (isCOMinterface())	1304	if (isCOMinterface())
1256	return 0;	1305	return 0;
1257	return 1;	1306	return 1;
1258	}	1307	}
1259		1308
1260	int InterfaceDeclaration::isCOMinterface()	1309	int InterfaceDeclaration::isCOMinterface()
1261	{	1310	{
1262	return com;	1311	return com;
1263	}	1312	}
1264		1313
		1314	#if DMDV2
		1315	int InterfaceDeclaration::isCPPinterface()
		1316	{
		1317	return cpp;
		1318	}
		1319	#endif
		1320
1265	/*******************************************	1321	/*******************************************
1266	*/	1322	*/
1267		1323
1268	const char *InterfaceDeclaration::kind()	1324	const char *InterfaceDeclaration::kind()
1269	{	1325	{
1270	return "interface";	1326	return "interface";
1271	}	1327	}
1272		1328
1273		1329
1274	/****************************** BaseClass ***************************/	1330	/****************************** BaseClass ***************************/
1275		1331
1276	BaseClass::BaseClass()	1332	BaseClass::BaseClass()
1277	{	1333	{
1278	memset(this, 0, sizeof(BaseClass));	1334	memset(this, 0, sizeof(BaseClass));
1279	}	1335	}
1280		1336
1281	BaseClass::BaseClass(Type *type, enum PROT protection)	1337	BaseClass::BaseClass(Type *type, enum PROT protection)
1282	{	1338	{
1283	//printf("BaseClass(this = %p, '%s')\n", this, type->toChars());	1339	//printf("BaseClass(this = %p, '%s')\n", this, type->toChars());
1284	this->type = type;	1340	this->type = type;

dmd/constfold.c

Revision 1367:8026319762be		Revision 1587:def7a1d494fd
53		53
54	/* ================================== isConst() ============================== */	54	/* ================================== isConst() ============================== */
55		55
56	int Expression::isConst()	56	int Expression::isConst()
57	{	57	{
58	//printf("Expression::isConst(): %s\n", toChars());	58	//printf("Expression::isConst(): %s\n", toChars());
59	return 0;	59	return 0;
60	}	60	}
61		61
62	int IntegerExp::isConst()	62	int IntegerExp::isConst()
63	{	63	{
64	return 1;	64	return 1;
65	}	65	}
66		66
67	int RealExp::isConst()	67	int RealExp::isConst()
68	{	68	{
69	return 1;	69	return 1;
70	}	70	}
71		71
72	int ComplexExp::isConst()	72	int ComplexExp::isConst()
		73	{
		74	return 1;
		75	}
		76
		77	int NullExp::isConst()
73	{	78	{
74	return 1;	79	return 1;
75	}	80	}
76		81
77	int SymOffExp::isConst()	82	int SymOffExp::isConst()
78	{	83	{
79	return 2;	84	return 2;
80	}	85	}
81		86
82	/* =============================== constFold() ============================== */	87	/* =============================== constFold() ============================== */
83		88
84	/* The constFold() functions were redundant with the optimize() ones,	89	/* The constFold() functions were redundant with the optimize() ones,
85	* and so have been folded in with them.	90	* and so have been folded in with them.
86	*/	91	*/
87		92
88	/* ========================================================================== */	93	/* ========================================================================== */
89		94
90	Expression Neg(Type type, Expression *e1)	95	Expression Neg(Type type, Expression *e1)
91	{ Expression *e;	96	{ Expression *e;
92	Loc loc = e1->loc;	97	Loc loc = e1->loc;
…		…
828	r1 = e1->toImaginary();	833	r1 = e1->toImaginary();
829	r2 = e2->toImaginary();	834	r2 = e2->toImaginary();
830	L1:	835	L1:
831	#if __DMC__	836	#if __DMC__
832	cmp = (r1 == r2);	837	cmp = (r1 == r2);
833	#else	838	#else
834	if (Port::isNan(r1) \|\| Port::isNan(r2)) // if unordered	839	if (Port::isNan(r1) \|\| Port::isNan(r2)) // if unordered
835	{	840	{
836	cmp = 0;	841	cmp = 0;
837	}	842	}
838	else	843	else
839	{	844	{
840	cmp = (r1 == r2);	845	cmp = (r1 == r2);
841	}	846	}
842	#endif	847	#endif
843	}	848	}
844	else if (e1->type->iscomplex())	849	else if (e1->type->iscomplex())
845	{	850	{
846	cmp = e1->toComplex() == e2->toComplex();	851	cmp = e1->toComplex() == e2->toComplex();
847	}	852	}
848	else if (e1->type->isintegral())	853	else if (e1->type->isintegral() \|\| e1->type->toBasetype()->ty == Tpointer)
849	{	854	{
850	cmp = (e1->toInteger() == e2->toInteger());	855	cmp = (e1->toInteger() == e2->toInteger());
851	}	856	}
852	else	857	else
853	return EXP_CANT_INTERPRET;	858	return EXP_CANT_INTERPRET;
854	if (op == TOKnotequal)	859	if (op == TOKnotequal)
855	cmp ^= 1;	860	cmp ^= 1;
856	e = new IntegerExp(loc, cmp, type);	861	e = new IntegerExp(loc, cmp, type);
857	return e;	862	return e;
858	}	863	}
859		864
860	Expression Identity(enum TOK op, Type type, Expression e1, Expression e2)	865	Expression Identity(enum TOK op, Type type, Expression e1, Expression e2)
861	{ Expression *e;	866	{ Expression *e;
862	Loc loc = e1->loc;	867	Loc loc = e1->loc;
863	int cmp;	868	int cmp;
864		869
865	if (e1->op == TOKnull && e2->op == TOKnull)	870	if (e1->op == TOKnull)
866	{	871	{
867	cmp = 1;	872	cmp = (e2->op == TOKnull);
		873	}
		874	else if (e2->op == TOKnull)
		875	{
		876	cmp = 0;
868	}	877	}
869	else if (e1->op == TOKsymoff && e2->op == TOKsymoff)	878	else if (e1->op == TOKsymoff && e2->op == TOKsymoff)
870	{	879	{
871	SymOffExp es1 = (SymOffExp )e1;	880	SymOffExp es1 = (SymOffExp )e1;
872	SymOffExp es2 = (SymOffExp )e2;	881	SymOffExp es2 = (SymOffExp )e2;
873		882
874	cmp = (es1->var == es2->var && es1->offset == es2->offset);	883	cmp = (es1->var == es2->var && es1->offset == es2->offset);
875	}	884	}
876	else if (e1->isConst() == 1 && e2->isConst() == 1)	885	else if (e1->isConst() == 1 && e2->isConst() == 1)
877	return Equal((op == TOKidentity) ? TOKequal : TOKnotequal,	886	return Equal((op == TOKidentity) ? TOKequal : TOKnotequal,
878	type, e1, e2);	887	type, e1, e2);
879	else	888	else
880	assert(0);	889	assert(0);
881	if (op == TOKnotidentity)	890	if (op == TOKnotidentity)
882	cmp ^= 1;	891	cmp ^= 1;
883	return new IntegerExp(loc, cmp, type);	892	return new IntegerExp(loc, cmp, type);
884	}	893	}
885		894
886		895
887	Expression Cmp(enum TOK op, Type type, Expression e1, Expression e2)	896	Expression Cmp(enum TOK op, Type type, Expression e1, Expression e2)
…		…
1029	}	1038	}
1030	e = new IntegerExp(loc, n, type);	1039	e = new IntegerExp(loc, n, type);
1031	return e;	1040	return e;
1032	}	1041	}
1033		1042
1034	/* Also returns EXP_CANT_INTERPRET if cannot be computed.	1043	/* Also returns EXP_CANT_INTERPRET if cannot be computed.
1035	* to: type to cast to	1044	* to: type to cast to
1036	* type: type to paint the result	1045	* type: type to paint the result
1037	*/	1046	*/
1038		1047
1039	Expression Cast(Type type, Type to, Expression e1)	1048	Expression Cast(Type type, Type to, Expression e1)
1040	{ Expression *e = EXP_CANT_INTERPRET;	1049	{ Expression *e = EXP_CANT_INTERPRET;
1041	Loc loc = e1->loc;	1050	Loc loc = e1->loc;
1042		1051
1043	//printf("Cast(type = %s, to = %s, e1 = %s)\n", type->toChars(), to->toChars(), e1->toChars());	1052	//printf("Cast(type = %s, to = %s, e1 = %s)\n", type->toChars(), to->toChars(), e1->toChars());
1044	//printf("e1->type = %s\n", e1->type->toChars());	1053	//printf("e1->type = %s\n", e1->type->toChars());
1045	if (type->equals(e1->type) && to->equals(type))	1054	if (type->equals(e1->type) && to->equals(type))
1046	return e1;	1055	return e1;
1047		1056
1048	Type *tb = to->toBasetype();	1057	Type *tb = to->toBasetype();
1049	Type *typeb = type->toBasetype();	1058
1050		1059	/* Allow casting from one string type to another
1051	~~// LDC: ported from D2 to allow char[] ~ char[n] arguments in CTFE~~	1060	*/
1052	if (e1->op == TOKstring)	1061	if (e1->op == TOKstring)
1053	{	1062	{
		1063	Type *typeb = type->toBasetype();
1054	if (tb->ty == Tarray && typeb->ty == Tarray &&	1064	if (tb->ty == Tarray && typeb->ty == Tarray &&
1055	tb->nextOf()->size() == typeb->nextOf()->size())	1065	tb->nextOf()->size() == typeb->nextOf()->size())
1056	{	1066	{
1057	return expType(to, e1);	1067	return expType(to, e1);
1058	}	1068	}
1059	}	1069	}
1060		1070
1061	if (e1->isConst() != 1)	1071	if (e1->isConst() != 1)
1062	return EXP_CANT_INTERPRET;	1072	return EXP_CANT_INTERPRET;
1063		1073
1064	if (tb->ty == Tbool)	1074	if (tb->ty == Tbool)
1065	e = new IntegerExp(loc, e1->toInteger() != 0, type);	1075	e = new IntegerExp(loc, e1->toInteger() != 0, type);
1066	else if (type->isintegral())	1076	else if (type->isintegral())
1067	{	1077	{
1068	if (e1->type->isfloating())	1078	if (e1->type->isfloating())
1069	{ dinteger_t result;	1079	{ dinteger_t result;
1070	real_t r = e1->toReal();	1080	real_t r = e1->toReal();
1071		1081
1072	switch (typeb->ty)	1082	switch (type->toBasetype()->ty)
1073	{	1083	{
1074	case Tint8: result = (d_int8)r; break;	1084	case Tint8: result = (d_int8)r; break;
1075	case Tchar:	1085	case Tchar:
1076	case Tuns8: result = (d_uns8)r; break;	1086	case Tuns8: result = (d_uns8)r; break;
1077	case Tint16: result = (d_int16)r; break;	1087	case Tint16: result = (d_int16)r; break;
1078	case Twchar:	1088	case Twchar:
1079	case Tuns16: result = (d_uns16)r; break;	1089	case Tuns16: result = (d_uns16)r; break;
1080	case Tint32: result = (d_int32)r; break;	1090	case Tint32: result = (d_int32)r; break;
1081	case Tdchar:	1091	case Tdchar:
1082	case Tuns32: result = (d_uns32)r; break;	1092	case Tuns32: result = (d_uns32)r; break;
1083	case Tint64: result = (d_int64)r; break;	1093	case Tint64: result = (d_int64)r; break;
1084	case Tuns64: result = (d_uns64)r; break;	1094	case Tuns64: result = (d_uns64)r; break;
1085	default:	1095	default:
1086	assert(0);	1096	assert(0);
1087	}	1097	}
1088		1098
1089	e = new IntegerExp(loc, result, type);	1099	e = new IntegerExp(loc, result, type);
1090	}	1100	}
1091	else if (type->isunsigned())	1101	else if (type->isunsigned())
1092	e = new IntegerExp(loc, e1->toUInteger(), type);	1102	e = new IntegerExp(loc, e1->toUInteger(), type);

dmd/declaration.c

Revision 1538:e4ff2e15cf5f		Revision 1587:def7a1d494fd
50	assert(type);	50	assert(type);
51	return type->size();	51	return type->size();
52	}	52	}
53		53
54	int Declaration::isStaticConstructor()	54	int Declaration::isStaticConstructor()
55	{	55	{
56	return FALSE;	56	return FALSE;
57	}	57	}
58		58
59	int Declaration::isStaticDestructor()	59	int Declaration::isStaticDestructor()
60	{	60	{
61	return FALSE;	61	return FALSE;
62	}	62	}
63		63
64	int Declaration::isDelete()	64	int Declaration::isDelete()
65	{	65	{
66	return FALSE;	66	return FALSE;
67	}	67	}
68		68
69	int Declaration::isDataseg()	69	int Declaration::isDataseg()
		70	{
		71	return FALSE;
		72	}
		73
		74	int Declaration::isThreadlocal()
70	{	75	{
71	return FALSE;	76	return FALSE;
72	}	77	}
73		78
74	int Declaration::isCodeseg()	79	int Declaration::isCodeseg()
75	{	80	{
76	return FALSE;	81	return FALSE;
77	}	82	}
78		83
79	enum PROT Declaration::prot()	84	enum PROT Declaration::prot()
80	{	85	{
81	return protection;	86	return protection;
82	}	87	}
83		88
84	/*************************************	89	/*************************************
85	* Check to see if declaration can be modified in this context (sc).	90	* Check to see if declaration can be modified in this context (sc).
86	* Issue error if not.	91	* Issue error if not.
87	*/	92	*/
88		93
89	#if DMDV2	94	#if DMDV2
…		…
115	{	120	{
116	if (s)	121	if (s)
117	{ s = s->toParent2();	122	{ s = s->toParent2();
118	continue;	123	continue;
119	}	124	}
120	else	125	else
121	{	126	{
122	const char *p = isStatic() ? "static " : "";	127	const char *p = isStatic() ? "static " : "";
123	error(loc, "can only initialize %sconst %s inside %sconstructor",	128	error(loc, "can only initialize %sconst %s inside %sconstructor",
124	p, toChars(), p);	129	p, toChars(), p);
125	}	130	}
126	}	131	}
127	break;	132	break;
128	}	133	}
129	}	134	}
130	else	135	else
131	{	136	{
132	VarDeclaration *v = isVarDeclaration();	137	VarDeclaration *v = isVarDeclaration();
133	if (v && v->canassign == 0)	138	if (v && v->canassign == 0)
134	{	139	{
135	char *p = NULL;	140	const char *p = NULL;
136	if (isConst())	141	if (isConst())
137	p = "const";	142	p = "const";
138	else if (isInvariant())	143	else if (isInvariant())
139	p = "i~~nvariant~~";	144	p = "immutable";
140	else if (storage_class & STCmanifest)	145	else if (storage_class & STCmanifest)
141	p = "~~manifest constant~~";	146	p = "enum";
142	else if (!t->isAssignable())	147	else if (!t->isAssignable())
143	p = "struct with immutable members";	148	p = "struct with immutable members";
144	if (p)	149	if (p)
145	{ error(loc, "cannot modify %s", p);	150	{ error(loc, "cannot modify %s", p);
146	~~halt();~~
147	}	151	}
148	}	152	}
149	}	153	}
150	}	154	}
151	#endif	155	#endif
152		156
153		157
154	/******************************* TupleDeclaration **************************/	158	/******************************* TupleDeclaration **************************/
155		159
156	TupleDeclaration::TupleDeclaration(Loc loc, Identifier id, Objects objects)	160	TupleDeclaration::TupleDeclaration(Loc loc, Identifier id, Objects objects)
157	: Declaration(id)	161	: Declaration(id)
158	{	162	{
159	this->type = NULL;	163	this->type = NULL;
160	this->objects = objects;	164	this->objects = objects;
161	this->isexp = 0;	165	this->isexp = 0;
162	this->tupletype = NULL;	166	this->tupletype = NULL;
163	}	167	}
164		168
165	Dsymbol TupleDeclaration::syntaxCopy(Dsymbol s)	169	Dsymbol TupleDeclaration::syntaxCopy(Dsymbol s)
166	{	170	{
…		…
183	return NULL;	187	return NULL;
184	if (!tupletype)	188	if (!tupletype)
185	{	189	{
186	/* It's only a type tuple if all the Object's are types	190	/* It's only a type tuple if all the Object's are types
187	*/	191	*/
188	for (size_t i = 0; i < objects->dim; i++)	192	for (size_t i = 0; i < objects->dim; i++)
189	{ Object o = (Object )objects->data[i];	193	{ Object o = (Object )objects->data[i];
190		194
191	if (o->dyncast() != DYNCAST_TYPE)	195	if (o->dyncast() != DYNCAST_TYPE)
192	{	196	{
193	//printf("\tnot[%d], %p, %d\n", i, o, o->dyncast());	197	//printf("\tnot[%d], %p, %d\n", i, o, o->dyncast());
194	return NULL;	198	return NULL;
195	}	199	}
196	}	200	}
197		201
198	/* We know it's a type tuple, so build the TypeTuple	202	/* We know it's a type tuple, so build the TypeTuple
199	*/	203	*/
200	Arguments *args = new Arguments();	204	Arguments *args = new Arguments();
201	args->setDim(objects->dim);	205	args->setDim(objects->dim);
202	OutBuffer buf;	206	OutBuffer buf;
		207	int hasdeco = 1;
203	for (size_t i = 0; i < objects->dim; i++)	208	for (size_t i = 0; i < objects->dim; i++)
204	{ Type t = (Type )objects->data[i];	209	{ Type t = (Type )objects->data[i];
205		210
206	//printf("type = %s\n", t->toChars());	211	//printf("type = %s\n", t->toChars());
207	#if 0	212	#if 0
208	buf.printf("_%s_%d", ident->toChars(), i);	213	buf.printf("_%s_%d", ident->toChars(), i);
209	char name = (char )buf.extractData();	214	char name = (char )buf.extractData();
210	Identifier *id = new Identifier(name, TOKidentifier);	215	Identifier *id = new Identifier(name, TOKidentifier);
211	Argument *arg = new Argument(STCin, t, id, NULL);	216	Argument *arg = new Argument(STCin, t, id, NULL);
212	#else	217	#else
213	Argument *arg = new Argument(STCin, t, NULL, NULL);	218	Argument *arg = new Argument(STCin, t, NULL, NULL);
214	#endif	219	#endif
215	args->data[i] = (void *)arg;	220	args->data[i] = (void *)arg;
		221	if (!t->deco)
		222	hasdeco = 0;
216	}	223	}
217		224
218	tupletype = new TypeTuple(args);	225	tupletype = new TypeTuple(args);
		226	if (hasdeco)
		227	return tupletype->semantic(0, NULL);
219	}	228	}
220		229
221	return tupletype;	230	return tupletype;
222	}	231	}
223		232
224	int TupleDeclaration::needThis()	233	int TupleDeclaration::needThis()
225	{	234	{
226	//printf("TupleDeclaration::needThis(%s)\n", toChars());	235	//printf("TupleDeclaration::needThis(%s)\n", toChars());
227	for (size_t i = 0; i < objects->dim; i++)	236	for (size_t i = 0; i < objects->dim; i++)
228	{ Object o = (Object )objects->data[i];	237	{ Object o = (Object )objects->data[i];
229	if (o->dyncast() == DYNCAST_EXPRESSION)	238	if (o->dyncast() == DYNCAST_EXPRESSION)
230	{ Expression e = (Expression )o;	239	{ Expression e = (Expression )o;
231	if (e->op == TOKdsymbol)	240	if (e->op == TOKdsymbol)
232	{ DsymbolExp ve = (DsymbolExp )e;	241	{ DsymbolExp ve = (DsymbolExp )e;
233	Declaration *d = ve->s->isDeclaration();	242	Declaration *d = ve->s->isDeclaration();
234	if (d && d->needThis())	243	if (d && d->needThis())
235	{	244	{
236	return 1;	245	return 1;
237	}	246	}
238	}	247	}
…		…
439		448
440	// Given:	449	// Given:
441	// alias foo.bar.abc def;	450	// alias foo.bar.abc def;
442	// it is not knowable from the syntax whether this is an alias	451	// it is not knowable from the syntax whether this is an alias
443	// for a type or an alias for a symbol. It is up to the semantic()	452	// for a type or an alias for a symbol. It is up to the semantic()
444	// pass to distinguish.	453	// pass to distinguish.
445	// If it is a type, then type is set and getType() will return that	454	// If it is a type, then type is set and getType() will return that
446	// type. If it is a symbol, then aliassym is set and type is NULL -	455	// type. If it is a symbol, then aliassym is set and type is NULL -
447	// toAlias() will return aliasssym.	456	// toAlias() will return aliasssym.
448		457
449	Dsymbol *s;	458	Dsymbol *s;
450	Type *t;	459	Type *t;
451	Expression *e;	460	Expression *e;
452		461
453	/* This section is needed because resolve() will:	462	/* This section is needed because resolve() will:
454	* const x = 3;	463	* const x = 3;
455	* alias x y;	464	* alias x y;
456	* try to alias y to 3.	465	* try to alias y to 3.
457	*/	466	*/
458	s = type->toDsymbol(sc);	467	s = type->toDsymbol(sc);
459	if (s)	468	if (s
		469	#if DMDV2
		470	` && ((s->getType() && type->equals(s->getType())) \|\| s->isEnumMember())
		471	#endif
		472	)
460	goto L2; // it's a symbolic alias	473	goto L2; // it's a symbolic alias
461		474
462	//printf("alias type is %s\n", type->toChars());	475	#if DMDV2
463	type->resolve(loc, sc, &e, &t, &s);	476	if (storage_class & (STCref \| STCnothrow \| STCpure))
		477	{ // For 'ref' to be attached to function types, and picked
		478	// up by Type::resolve(), it has to go into sc.
		479	sc = sc->push();
		480	sc->stc \|= storage_class & (STCref \| STCnothrow \| STCpure);
		481	type->resolve(loc, sc, &e, &t, &s);
		482	sc = sc->pop();
		483	}
		484	else
		485	#endif
		486	type->resolve(loc, sc, &e, &t, &s);
464	if (s)	487	if (s)
465	{	488	{
466	goto L2;	489	goto L2;
467	}	490	}
468	else if (e)	491	else if (e)
469	{	492	{
470	// Try to convert Expression to Dsymbol	493	// Try to convert Expression to Dsymbol
471	if (e->op == TOKvar)	494	if (e->op == TOKvar)
472	{ s = ((VarExp *)e)->var;	495	{ s = ((VarExp *)e)->var;
473	goto L2;	496	goto L2;
474	}	497	}
475	else if (e->op == TOKfunction)	498	else if (e->op == TOKfunction)
476	{ s = ((FuncExp *)e)->fd;	499	{ s = ((FuncExp *)e)->fd;
477	goto L2;	500	goto L2;
478	}	501	}
479	else	502	else
480	{ error("cannot alias an expression %s", e->toChars());	503	{ error("cannot alias an expression %s", e->toChars());
481	t = e->type;	504	t = e->type;
482	}	505	}
483	}	506	}
…		…
506	{	529	{
507	if (overnext)	530	if (overnext)
508	{	531	{
509	FuncAliasDeclaration *fa = new FuncAliasDeclaration(f);	532	FuncAliasDeclaration *fa = new FuncAliasDeclaration(f);
510	fa->importprot = importprot;	533	fa->importprot = importprot;
511	if (!fa->overloadInsert(overnext))	534	if (!fa->overloadInsert(overnext))
512	ScopeDsymbol::multiplyDefined(0, f, overnext);	535	ScopeDsymbol::multiplyDefined(0, f, overnext);
513	overnext = NULL;	536	overnext = NULL;
514	s = fa;	537	s = fa;
515	s->parent = sc->parent;	538	s->parent = sc->parent;
516	}	539	}
517	}	540	}
518	if (overnext)	541	if (overnext)
519	ScopeDsymbol::multiplyDefined(0, s, overnext);	542	ScopeDsymbol::multiplyDefined(0, s, overnext);
520	if (s == this)	543	if (s == this)
521	{	544	{
522	assert(global.errors);	545	assert(global.errors);
523	s = NULL;	546	s = NULL;
524	}	547	}
525	}	548	}
526	aliassym = s;	549	if (!aliassym)
		550	aliassym = s;
527	this->inSemantic = 0;	551	this->inSemantic = 0;
528	}	552	}
529		553
530	int AliasDeclaration::overloadInsert(Dsymbol *s)	554	int AliasDeclaration::overloadInsert(Dsymbol *s)
531	{	555	{
532	/* Don't know yet what the aliased symbol is, so assume it can	556	/* Don't know yet what the aliased symbol is, so assume it can
533	* be overloaded and check later for correctness.	557	* be overloaded and check later for correctness.
534	*/	558	*/
535		559
536	//printf("AliasDeclaration::overloadInsert('%s')\n", s->toChars());	560	//printf("AliasDeclaration::overloadInsert('%s')\n", s->toChars());
537	if (overnext == NULL)	561	if (overnext == NULL)
538	{ overnext = s;	562	{
		563	if (s == this)
		564	{
		565	return TRUE;
		566	}
		567	overnext = s;
539	return TRUE;	568	return TRUE;
540	}	569	}
541	else	570	else
542	{	571	{
543	return overnext->overloadInsert(s);	572	return overnext->overloadInsert(s);
544	}	573	}
545	}	574	}
546		575
547	const char *AliasDeclaration::kind()	576	const char *AliasDeclaration::kind()
548	{	577	{
549	return "alias";	578	return "alias";
550	}	579	}
551		580
552	Type *AliasDeclaration::getType()	581	Type *AliasDeclaration::getType()
553	{	582	{
		583	//printf("AliasDeclaration::getType() %s\n", type->toChars());
		584	#if 0
		585	if (!type->deco && scope)
		586	semantic(scope);
		587	if (type && !type->deco)
		588	error("forward reference to alias %s\n", toChars());
		589	#endif
554	return type;	590	return type;
555	}	591	}
556		592
557	Dsymbol *AliasDeclaration::toAlias()	593	Dsymbol *AliasDeclaration::toAlias()
558	{	594	{
559	//printf("AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s')\n", toChars(), this, aliassym, aliassym ? aliassym->kind() : "");	595	//printf("AliasDeclaration::toAlias('%s', this = %p, aliassym = %p, kind = '%s')\n", toChars(), this, aliassym, aliassym ? aliassym->kind() : "");
560	assert(this != aliassym);	596	assert(this != aliassym);
561	//static int count; if (++count == ~~10)~~ (char)0=0;	597	//static int count; if (++count == 75) exit(0); //(char)0=0;
562	if (inSemantic)	598	if (inSemantic)
563	{ error("recursive alias declaration");	599	{ error("recursive alias declaration");
564	aliassym = new TypedefDeclaration(loc, ident, Type::terror, NULL);	600	aliassym = new TypedefDeclaration(loc, ident, Type::terror, NULL);
565	}	601	}
566	Dsymbol *s = aliassym ? aliassym->toAlias() : this;	602	Dsymbol *s = aliassym ? aliassym->toAlias() : this;
567	return s;	603	return s;
568	}	604	}
569		605
570	void AliasDeclaration::toCBuffer(OutBuffer buf, HdrGenState hgs)	606	void AliasDeclaration::toCBuffer(OutBuffer buf, HdrGenState hgs)
571	{	607	{
572	buf->writestring("alias ");	608	buf->writestring("alias ");
573	#if 0 && _DH	609	#if 0 && _DH
574	if (hgs->hdrgen)	610	if (hgs->hdrgen)
575	{	611	{
576	if (haliassym)	612	if (haliassym)
577	{	613	{
578	buf->writestring(haliassym->toChars());	614	buf->writestring(haliassym->toChars());
579	buf->writeByte(' ');	615	buf->writeByte(' ');
580	buf->writestring(ident->toChars());	616	buf->writestring(ident->toChars());
581	}	617	}
…		…
603	VarDeclaration::VarDeclaration(Loc loc, Type type, Identifier id, Initializer *init)	639	VarDeclaration::VarDeclaration(Loc loc, Type type, Identifier id, Initializer *init)
604	: Declaration(id)	640	: Declaration(id)
605	{	641	{
606	//printf("VarDeclaration('%s')\n", id->toChars());	642	//printf("VarDeclaration('%s')\n", id->toChars());
607	#ifdef DEBUG	643	#ifdef DEBUG
608	if (!type && !init)	644	if (!type && !init)
609	{ printf("VarDeclaration('%s')\n", id->toChars());	645	{ printf("VarDeclaration('%s')\n", id->toChars());
610	//(char)0=0;	646	//(char)0=0;
611	}	647	}
612	#endif	648	#endif
613	assert(type \|\| init);	649	assert(type \|\| init);
614	this->type = type;	650	this->type = type;
615	this->init = init;	651	this->init = init;
616	#ifdef _DH	652	#ifdef _DH
617	this->htype = NULL;	653	this->htype = NULL;
618	this->hinit = NULL;	654	this->hinit = NULL;
619	#endif	655	#endif
620	this->loc = loc;	656	this->loc = loc;
621	offset = 0;	657	offset = 0;
622	noscope = 0;	658	noscope = 0;
		659	#if DMDV1
623	nestedref = 0;	660	nestedref = 0;
		661	#endif
624	ctorinit = 0;	662	ctorinit = 0;
625	aliassym = NULL;	663	aliassym = NULL;
626	onstack = 0;	664	onstack = 0;
627	canassign = 0;	665	canassign = 0;
628	value = NULL;	666	value = NULL;
629		667
630	#if IN_LLVM	668	#if IN_LLVM
631	aggrIndex = 0;	669	aggrIndex = 0;
632		670
633	// LDC	671	// LDC
634	anonDecl = NULL;	672	anonDecl = NULL;
635	offset2 = 0;	673	offset2 = 0;
636		674
637	nakedUse = false;	675	nakedUse = false;
638		676
639	availableExternally = true; // assume this unless proven otherwise	677	availableExternally = true; // assume this unless proven otherwise
640	#endif	678	#endif
641	}	679	}
642		680
643	Dsymbol VarDeclaration::syntaxCopy(Dsymbol s)	681	Dsymbol VarDeclaration::syntaxCopy(Dsymbol s)
…		…
667	{ htype = type->syntaxCopy();	705	{ htype = type->syntaxCopy();
668	sv->htype = type->syntaxCopy();	706	sv->htype = type->syntaxCopy();
669	}	707	}
670	}	708	}
671	else // Make copy of original for new instance	709	else // Make copy of original for new instance
672	sv->htype = htype->syntaxCopy();	710	sv->htype = htype->syntaxCopy();
673	if (!hinit)	711	if (!hinit)
674	{ if (init)	712	{ if (init)
675	{ hinit = init->syntaxCopy();	713	{ hinit = init->syntaxCopy();
676	sv->hinit = init->syntaxCopy();	714	sv->hinit = init->syntaxCopy();
677	}	715	}
678	}	716	}
679	else	717	else
680	sv->hinit = hinit->syntaxCopy();	718	sv->hinit = hinit->syntaxCopy();
681	#endif	719	#endif
682	return sv;	720	return sv;
683	}	721	}
684		722
685	void VarDeclaration::semantic(Scope *sc)	723	void VarDeclaration::semantic(Scope *sc)
686	{	724	{
687	//printf("VarDeclaration::semantic('%s', parent = '%s')\n", toChars(), sc->parent->toChars());	725	#if 0
688	//printf(" type = %s\n", type ? type->toChars() : "null");	726	printf("VarDeclaration::semantic('%s', parent = '%s')\n", toChars(), sc->parent->toChars());
689	//printf(" stc = x%x\n", sc->stc);	727	printf(" type = %s\n", type ? type->toChars() : "null");
690	//printf(" storage_class = x%x\n", storage_class);	728	printf(" stc = x%x\n", sc->stc);
691	//printf("linkage = %d\n", sc->linkage);	729	printf(" storage_class = x%x\n", storage_class);
		730	printf("linkage = %d\n", sc->linkage);
692	//if (strcmp(toChars(), "mul") == 0) halt();	731	//if (strcmp(toChars(), "mul") == 0) halt();
		732	#endif
693		733
694	storage_class \|= sc->stc;	734	storage_class \|= sc->stc;
695	if (storage_class & STCextern && init)	735	if (storage_class & STCextern && init)
696	error("extern symbols cannot have initializers");	736	error("extern symbols cannot have initializers");
697		737
698	/* If auto type inference, do the inference	738	/* If auto type inference, do the inference
699	*/	739	*/
700	int inferred = 0;	740	int inferred = 0;
701	if (!type)	741	if (!type)
702	{ inuse++;	742	{ inuse++;
703	type = init->inferType(sc);	743	type = init->inferType(sc);
704	inuse--;	744	inuse--;
705	inferred = 1;	745	inferred = 1;
706		746
707	/* This is a kludge to support the existing syntax for RAII	747	/* This is a kludge to support the existing syntax for RAII
708	* declarations.	748	* declarations.
709	*/	749	*/
710	storage_class &= ~STCauto;	750	storage_class &= ~STCauto;
711	originalType = type;	751	originalType = type;
712	}	752	}
713	else	753	else
714	{ if (!originalType)	754	{ if (!originalType)
715	originalType = type;	755	originalType = type;
716	type = type->semantic(loc, sc);	756	type = type->semantic(loc, sc);
717	}	757	}
718	//printf(" semantic type = %s\n", type ? type->toChars() : "null");	758	//printf(" semantic type = %s\n", type ? type->toChars() : "null");
719		759
720	type->checkDeprecated(loc, sc);	760	type->checkDeprecated(loc, sc);
721	linkage = sc->linkage;	761	linkage = sc->linkage;
722	this->parent = sc->parent;	762	this->parent = sc->parent;
723	//printf("this = %p, parent = %p, '%s'\n", this, parent, parent->toChars());	763	//printf("this = %p, parent = %p, '%s'\n", this, parent, parent->toChars());
724	protection = sc->protection;	764	protection = sc->protection;
725	//printf("sc->stc = %x\n", sc->stc);	765	//printf("sc->stc = %x\n", sc->stc);
726	//printf("storage_class = x%x\n", storage_class);	766	//printf("storage_class = x%x\n", storage_class);
		767
		768	#if DMDV2
		769	if (storage_class & STCgshared && global.params.safe && !sc->module->safe)
		770	{
		771	error("__gshared not allowed in safe mode; use shared");
		772	}
		773	#endif
727		774
728	Dsymbol *parent = toParent();	775	Dsymbol *parent = toParent();
729	FuncDeclaration *fd = parent->isFuncDeclaration();	776	FuncDeclaration *fd = parent->isFuncDeclaration();
730		777
731	Type *tb = type->toBasetype();	778	Type *tb = type->toBasetype();
732	if (tb->ty == Tvoid && !(storage_class & STClazy))	779	if (tb->ty == Tvoid && !(storage_class & STClazy))
733	{ error("voids have no value");	780	{ error("voids have no value");
734	type = Type::terror;	781	type = Type::terror;
735	tb = type;	782	tb = type;
736	}	783	}
737	if (tb->ty == Tfunction)	784	if (tb->ty == Tfunction)
738	{ error("cannot be declared to be a function");	785	{ error("cannot be declared to be a function");
739	type = Type::terror;	786	type = Type::terror;
740	tb = type;	787	tb = type;
741	}	788	}
742	if (tb->ty == Tstruct)	789	if (tb->ty == Tstruct)
743	{ TypeStruct ts = (TypeStruct )tb;	790	{ TypeStruct ts = (TypeStruct )tb;
744		791
745	if (!ts->sym->members)	792	if (!ts->sym->members)
746	{	793	{
…		…
815	error("variable %s cannot be synchronized", toChars());	862	error("variable %s cannot be synchronized", toChars());
816	}	863	}
817	else if (isOverride())	864	else if (isOverride())
818	{	865	{
819	error("override cannot be applied to variable");	866	error("override cannot be applied to variable");
820	}	867	}
821	else if (isAbstract())	868	else if (isAbstract())
822	{	869	{
823	error("abstract cannot be applied to variable");	870	error("abstract cannot be applied to variable");
824	}	871	}
825	else if (storage_class & STCtemplateparameter)	872	else if (storage_class & STCtemplateparameter)
826	{	873	{
827	}	874	}
828	else	875	else
829	{	876	{
830	AggregateDeclaration *aad = sc->anonAgg;	877	AggregateDeclaration *aad = sc->anonAgg;
831	if (!aad)	878	if (!aad)
832	aad = parent->isAggregateDeclaration();	879	aad = parent->isAggregateDeclaration();
833	if (aad)	880	if (aad)
834	{	881	{
835	aad->addField(sc, this);	882	#if DMDV2
		883	assert(!(storage_class & (STCextern \| STCstatic \| STCtls \| STCgshared)));
		884
		885	if (storage_class & (STCconst \| STCimmutable) && init)
		886	{
		887	if (!type->toBasetype()->isTypeBasic())
		888	storage_class \|= STCstatic;
		889	}
		890	else
		891	#endif
		892	aad->addField(sc, this);
836	}	893	}
837		894
838	InterfaceDeclaration *id = parent->isInterfaceDeclaration();	895	InterfaceDeclaration *id = parent->isInterfaceDeclaration();
839	if (id)	896	if (id)
840	{	897	{
841	error("field not allowed in interface");	898	error("field not allowed in interface");
842	}	899	}
843		900
844	/* Templates cannot add fields to aggregates	901	/* Templates cannot add fields to aggregates
845	*/	902	*/
846	TemplateInstance *ti = parent->isTemplateInstance();	903	TemplateInstance *ti = parent->isTemplateInstance();
847	if (ti)	904	if (ti)
848	{	905	{
849	// Take care of nested templates	906	// Take care of nested templates
850	while (1)	907	while (1)
851	{	908	{
852	TemplateInstance *ti2 = ti->tempdecl->parent->isTemplateInstance();	909	TemplateInstance *ti2 = ti->tempdecl->parent->isTemplateInstance();
853	if (!ti2)	910	if (!ti2)
854	break;	911	break;
855	ti = ti2;	912	ti = ti2;
856	}	913	}
857		914
858	// If it's a member template	915	// If it's a member template
859	AggregateDeclaration *ad = ti->tempdecl->isMember();	916	AggregateDeclaration *ad = ti->tempdecl->isMember();
860	if (ad && storage_class != STCundefined)	917	if (ad && storage_class != STCundefined)
861	{	918	{
862	error("cannot use template to add field to aggregate '%s'", ad->toChars());	919	error("cannot use template to add field to aggregate '%s'", ad->toChars());
863	}	920	}
864	}	921	}
865	}	922	}
866		923
		924	#if DMDV2
		925	if ((storage_class & (STCref \| STCparameter \| STCforeach)) == STCref &&
		926	ident != Id::This)
		927	{
		928	error("only parameters or foreach declarations can be ref");
		929	}
		930	#endif
		931
867	if (type->isscope() && !noscope)	932	if (type->isscope() && !noscope)
868	{	933	{
869	if (storage_class & (STCfield \| STCout \| STCref \| STCstatic) \|\| !fd)	934	if (storage_class & (STCfield \| STCout \| STCref \| STCstatic) \|\| !fd)
870	{	935	{
871	error("globals, statics, fields, ref and out parameters cannot be scope");	936	error("globals, statics, fields, ref and out parameters cannot be scope");
872	}	937	}
873		938
874	if (!(storage_class & STCscope))	939	if (!(storage_class & STCscope))
875	{	940	{
876	if (!(storage_class & STCparameter) && ident != Id::withSym)	941	if (!(storage_class & STCparameter) && ident != Id::withSym)
877	error("reference to scope class must be scope");	942	error("reference to scope class must be scope");
878	}	943	}
879	}	944	}
880		945
		946	enum TOK op = TOKconstruct;
881	if (!init && !sc->inunion && !isStatic() && !isConst() && fd &&	947	if (!init && !sc->inunion && !isStatic() && !isConst() && fd &&
882	!(storage_class & (STCfield \| STCin \| STCforeach)) &&	948	!(storage_class & (STCfield \| STCin \| STCforeach)) &&
883	type->size() != 0)	949	type->size() != 0)
884	{	950	{
885	// Provide a default initializer	951	// Provide a default initializer
886	//printf("Providing default initializer for '%s'\n", toChars());	952	//printf("Providing default initializer for '%s'\n", toChars());
887	if (type->ty == Tstruct &&	953	if (type->ty == Tstruct &&
888	((TypeStruct *)type)->sym->zeroInit == 1)	954	((TypeStruct *)type)->sym->zeroInit == 1)
889	{ /* If a struct is all zeros, as a special case	955	{ /* If a struct is all zeros, as a special case
890	* set it's initializer to the integer 0.	956	* set it's initializer to the integer 0.
891	* In AssignExp::toElem(), we check for this and issue	957	* In AssignExp::toElem(), we check for this and issue
892	* a memset() to initialize the struct.	958	* a memset() to initialize the struct.
893	* Must do same check in interpreter.	959	* Must do same check in interpreter.
894	*/	960	*/
895	Expression *e = new IntegerExp(loc