Changeset 881

Show
Ignore:
Timestamp:
03/08/08 17:08:58 (6 months ago)
Author:
Gregor
Message:

MERGE: DMD 2.010

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/dmdfe-2.0/cast.c

    r880 r881  
    3535    //printf("%s\n", toChars()); 
    3636 
    37     if (implicitConvTo(t)) 
     37    MATCH match = implicitConvTo(t); 
     38    if (match) 
    3839    { 
    3940    if (global.params.warnings && 
    …… 
    4950        error("implicit conversion of expression (%s) of type %s to %s can cause loss of data", 
    5051        toChars(), type->toChars(), t->toChars()); 
     52    } 
     53    if (match == MATCHconst && t == type->constOf()) 
     54    { 
     55        Expression *e = copy(); 
     56        e->type = t; 
     57        return e; 
    5158    } 
    5259    return castTo(sc, t); 

  • branches/dmdfe-2.0/declaration.c

    r880 r881  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    386386Dsymbol *AliasDeclaration::syntaxCopy(Dsymbol *s) 
    387387{ 
     388    //printf("AliasDeclaration::syntaxCopy()\n"); 
    388389    assert(!s); 
    389390    AliasDeclaration *sa; 
    …… 
    660661    //printf(" type = %s\n", type ? type->toChars() : "null"); 
    661662    //printf(" stc = x%x\n", sc->stc); 
     663    //printf(" storage_class = x%x\n", storage_class); 
    662664    //printf("linkage = %d\n", sc->linkage); 
    663665    //if (strcmp(toChars(), "mul") == 0) halt(); 
    …… 
    12801282{   Expression *e = NULL; 
    12811283 
     1284    //printf("VarDeclaration::callAutoDtor() %s\n", toChars()); 
    12821285    if (storage_class & (STCauto | STCscope) && !noauto) 
    12831286    { 
    …… 
    12901293         * could be set. 
    12911294         */ 
     1295        if (cd->isInterfaceDeclaration()) 
     1296        error("interface %s cannot be scope", cd->toChars()); 
    12921297        if (1 || onstack || cd->dtors.dim)  // if any destructors 
    12931298        { 

  • branches/dmdfe-2.0/dsymbol.c

    r880 r881  
    395395AggregateDeclaration *Dsymbol::isMember()   // is this a member of an AggregateDeclaration? 
    396396{ 
     397    //printf("Dsymbol::isMember() %s\n", toChars()); 
    397398    Dsymbol *parent = toParent(); 
     399    //printf("parent is %s %s\n", parent->kind(), parent->toChars()); 
    398400    return parent ? parent->isAggregateDeclaration() : NULL; 
    399401} 

  • branches/dmdfe-2.0/expression.c

    r880 r881  
    521521    L1: 
    522522        if (!(p->storageClass & STClazy && p->type->ty == Tvoid)) 
    523         arg = arg->implicitCastTo(sc, p->type); 
    524         if (p->storageClass & (STCout | STCref)) 
    525523        { 
    526         // BUG: should check that argument to ref is type 'invariant' 
    527         // BUG: assignments to ref should also be type 'invariant' 
    528         arg = arg->modifiableLvalue(sc, NULL); 
    529  
    530         //if (arg->op == TOKslice) 
    531             //arg->error("cannot modify slice %s", arg->toChars()); 
     524        if (p->type != arg->type) 
     525        { 
     526            //printf("arg->type = %s, p->type = %s\n", arg->type->toChars(), p->type->toChars()); 
     527            arg = arg->implicitCastTo(sc, p->type); 
     528            arg = arg->optimize(WANTvalue); 
     529        } 
     530        } 
     531        if (p->storageClass & STCref) 
     532        { 
     533        arg = arg->toLvalue(sc, arg); 
     534        } 
     535        else if (p->storageClass & STCout) 
     536        { 
     537        arg = arg->modifiableLvalue(sc, arg); 
    532538        } 
    533539 
    …… 
    32253231 
    32263232        tf = (TypeFunction *)f->type; 
    3227       type = tf->next; 
     3233//        type = tf->next; 
    32283234 
    32293235        if (!arguments) 
    …… 
    44344440        return e; 
    44354441 
    4436     e1 = e1->modifiableLvalue(sc, NULL); 
     4442    e1 = e1->modifiableLvalue(sc, e1); 
    44374443    e1->checkScalar(); 
    44384444    type = e1->type; 
    …… 
    44654471        return e; 
    44664472 
    4467     e1 = e1->modifiableLvalue(sc, NULL); 
     4473    e1 = e1->modifiableLvalue(sc, e1); 
    44684474    e1->checkScalar(); 
    44694475    type = e1->type; 
    …… 
    70757081 
    70767082    e = this; 
    7077     e1 = e1->modifiableLvalue(sc, NULL); 
     7083    e1 = e1->modifiableLvalue(sc, e1); 
    70787084    e1->checkScalar(); 
    70797085    e1->checkNoBool(); 
    …… 
    72447250    /* If it is an assignment from a 'foreign' type, 
    72457251     * check for operator overloading. 
     7252     * Changed in V2 to be for structs only. 
    72467253     */ 
    7247     if (t1->ty == Tclass || t1->ty == Tstruct) 
     7254    if (t1->ty == Tstruct) 
    72487255    { 
    72497256    if (!e2->type->implicitConvTo(e1->type)) 
    …… 
    72627269    ArrayLengthExp *ale = (ArrayLengthExp *)e1; 
    72637270 
    7264     ale->e1 = ale->e1->modifiableLvalue(sc, NULL); 
     7271    ale->e1 = ale->e1->modifiableLvalue(sc, e1); 
    72657272    } 
    72667273    else if (e1->op == TOKslice) 
    …… 
    73347341    return e; 
    73357342 
    7336     e1 = e1->modifiableLvalue(sc, NULL); 
     7343    e1 = e1->modifiableLvalue(sc, e1); 
    73377344 
    73387345    Type *tb1 = e1->type->toBasetype(); 
    …… 
    74347441    return e; 
    74357442 
    7436     e1 = e1->modifiableLvalue(sc, NULL); 
     7443    e1 = e1->modifiableLvalue(sc, e1); 
    74377444    e1->checkScalar(); 
    74387445    e1->checkNoBool(); 
    …… 
    74797486    } 
    74807487 
    7481     e1 = e1->modifiableLvalue(sc, NULL); 
     7488    e1 = e1->modifiableLvalue(sc, e1); 
    74827489 
    74837490    Type *tb1 = e1->type->toBasetype(); 
    …… 
    75287535    return e; 
    75297536 
    7530     e1 = e1->modifiableLvalue(sc, NULL); 
     7537    e1 = e1->modifiableLvalue(sc, e1); 
    75317538    e1->checkScalar(); 
    75327539    e1->checkNoBool(); 
    …… 
    75847591    return e; 
    75857592 
    7586     e1 = e1->modifiableLvalue(sc, NULL); 
     7593    e1 = e1->modifiableLvalue(sc, e1); 
    75877594    e1->checkScalar(); 
    75887595    e1->checkNoBool(); 
    …… 
    76557662    return e; 
    76567663 
    7657     e1 = e1->modifiableLvalue(sc, NULL); 
     7664    e1 = e1->modifiableLvalue(sc, e1); 
    76587665    e1->checkScalar(); 
    76597666    e1->checkNoBool(); 
    …… 
    76837690    return e; 
    76847691 
    7685     e1 = e1->modifiableLvalue(sc, NULL); 
     7692    e1 = e1->modifiableLvalue(sc, e1); 
    76867693    e1->checkScalar(); 
    76877694    e1->checkNoBool(); 
    …… 
    77117718    return e; 
    77127719 
    7713     e1 = e1->modifiableLvalue(sc, NULL); 
     7720    e1 = e1->modifiableLvalue(sc, e1); 
    77147721    e1->checkScalar(); 
    77157722    e1->checkNoBool(); 

  • branches/dmdfe-2.0/func.c

    r880 r881  
    17821782int FuncDeclaration::isWinMain() 
    17831783{ 
     1784    //printf("FuncDeclaration::isWinMain() %s\n", toChars()); 
     1785#if 0 
     1786    int x = ident == Id::WinMain && 
     1787    linkage != LINKc && !isMember(); 
     1788    printf("%s\n", x ? "yes" : "no"); 
     1789    return x; 
     1790#else 
    17841791    return ident == Id::WinMain && 
    17851792    linkage != LINKc && !isMember(); 
     1793#endif 
    17861794} 
    17871795 
    …… 
    18591867    //if (!toParent()) 
    18601868    //printf("FuncDeclaration::isNested('%s') parent=%p\n", toChars(), parent); 
    1861     //printf("\ttoParent() = '%s'\n", toParent()->toChars()); 
     1869    //printf("\ttoParent2() = '%s'\n", toParent2()->toChars()); 
    18621870    return ((storage_class & STCstatic) == 0) && 
    18631871       (toParent2()->isFuncDeclaration() != NULL); 

  • branches/dmdfe-2.0/idgen.c

    r838 r881  
    192192    { "opIn_r" }, 
    193193    { "opStar" }, 
     194    { "opClone" }, 
    194195 
    195196    { "classNew", "new" }, 

  • branches/dmdfe-2.0/lexer.c

    r880 r881  
    21682168        if (d >= r) 
    21692169        break; 
    2170         if (n * r + d < n) 
     2170        if (n && n * r + d <= n) 
    21712171        { 
    21722172        error ("integer overflow"); 
    …… 
    28872887    {   "macro",    TOKmacro    }, 
    28882888#if V2 
     2889    {   "pure",     TOKpure     }, 
    28892890    {   "__traits", TOKtraits   }, 
    28902891    {   "__overloadset", TOKoverloadset }, 

  • branches/dmdfe-2.0/lexer.h

    r880 r881  
    154154    TOKtraits, 
    155155    TOKoverloadset, 
     156    TOKpure, 
    156157#endif 
    157158 

  • branches/dmdfe-2.0/mangle.c

    r880 r881  
    153153        return "_Dmain"; 
    154154 
     155    if (isWinMain() || isDllMain()) 
     156        return ident->toChars(); 
     157 
    155158    assert(this); 
    156159    return Declaration::mangle(); 

  • branches/dmdfe-2.0/mars.c

    r880 r881  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    5454    obj_ext  = "o"; 
    5555 
    56     copyright = "Copyright (c) 1999-2007 by Digital Mars"; 
     56    copyright = "Copyright (c) 1999-2008 by Digital Mars"; 
    5757    written = "written by Walter Bright"; 
    58     version = "v2.009"; 
     58    version = "v2.010"; 
    5959    global.structalign = 8; 
    6060 
    …… 
    110110    fprintf(stdmsg, "\n"); 
    111111    fflush(stdmsg); 
    112 //halt(); 
     112halt(); 
    113113    } 
    114114    global.errors++; 

  • branches/dmdfe-2.0/mtype.c

    r880 r881  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    23502350MATCH TypeDArray::implicitConvTo(Type *to) 
    23512351{ 
    2352     //printf("TypeDArray::implicitConvTo()\n"); 
     2352    //printf("TypeDArray::implicitConvTo(to = %s) this = %s\n", to->toChars(), toChars()); 
    23532353    if (equals(to)) 
    23542354    return MATCHexact; 
    …… 
    36963696    s = sc->search(loc, ident, &scopesym); 
    36973697    resolveHelper(loc, sc, s, scopesym, pe, pt, ps); 
     3698    if (*pt && mod) 
     3699    { 
     3700    if (mod & MODconst) 
     3701        *pt = (*pt)->constOf(); 
     3702    else if (mod & MODinvariant) 
     3703        *pt = (*pt)->invariantOf(); 
     3704    } 
    36983705} 
    36993706 
    …… 
    38393846    s->semantic(sc); 
    38403847    resolveHelper(loc, sc, s, NULL, pe, pt, ps); 
     3848    if (*pt && mod) 
     3849    { 
     3850    if (mod & MODconst) 
     3851        *pt = (*pt)->constOf(); 
     3852    else if (mod & MODinvariant) 
     3853        *pt = (*pt)->invariantOf(); 
     3854    } 
    38413855    //printf("pt = '%s'\n", (*pt)->toChars()); 
    38423856} 
    …… 
    43884402} 
    43894403 
     4404Expression *TypeTypedef::getProperty(Loc loc, Identifier *ident) 
     4405{ 
     4406#if LOGDOTEXP 
     4407    printf("TypeTypedef::getProperty(ident = '%s') '%s'\n", ident->toChars(), toChars()); 
     4408#endif 
     4409    if (ident == Id::init) 
     4410    { 
     4411    return Type::getProperty(loc, ident); 
     4412    } 
     4413    return sym->basetype->getProperty(loc, ident); 
     4414} 
     4415 
    43904416int TypeTypedef::isintegral() 
    43914417{ 
    …… 
    46954721    TemplateMixin *tm = s->isTemplateMixin(); 
    46964722    if (tm) 
    4697     {   Expression *de; 
    4698  
    4699     de = new DotExp(e->loc, e, new ScopeExp(e->loc, tm)); 
     4723    { 
     4724    Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, tm)); 
    47004725    de->type = e->type; 
    47014726    return de; 
    …… 
    47084733        e->semantic(sc); 
    47094734    return e; 
     4735    } 
     4736 
     4737    TemplateInstance *ti = s->isTemplateInstance(); 
     4738    if (ti) 
     4739    {   if (!ti->semanticdone) 
     4740        ti->semantic(sc); 
     4741    s = ti->inst->toAlias(); 
     4742    if (!s->isTemplateInstance()) 
     4743        goto L1; 
     4744    Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, ti)); 
     4745    de->type = e->type; 
     4746    return de; 
    47104747    } 
    47114748 
    …… 
    50895126    } 
    50905127 
     5128    TemplateInstance *ti = s->isTemplateInstance(); 
     5129    if (ti) 
     5130    {   if (!ti->semanticdone) 
     5131        ti->semantic(sc); 
     5132    s = ti->inst->toAlias(); 
     5133    if (!s->isTemplateInstance()) 
     5134        goto L1; 
     5135    Expression *de = new DotExp(e->loc, e, new ScopeExp(e->loc, ti)); 
     5136    de->type = e->type; 
     5137    return de; 
     5138    } 
     5139 
    50915140    d = s->isDeclaration(); 
    50925141    if (!d) 

  • branches/dmdfe-2.0/mtype.h

    r880 r881  
    613613    void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod); 
    614614    Expression *dotExp(Scope *sc, Expression *e, Identifier *ident); 
     615    Expression *getProperty(Loc loc, Identifier *ident); 
    615616    int isbit(); 
    616617    int isintegral(); 

  • branches/dmdfe-2.0/parse.c

    r880 r881  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    387387        Lprot: 
    388388        nextToken(); 
     389        switch (token.value) 
     390        { 
     391            case TOKprivate: 
     392            case TOKpackage: 
     393            case TOKprotected: 
     394            case TOKpublic: 
     395            case TOKexport: 
     396            error("redundant protection attribute"); 
     397            break; 
     398        } 
    389399        a = parseBlock(); 
    390400        s = new ProtDeclaration(prot, a); 
    …… 
    12541264BaseClasses *Parser::parseBaseClasses() 
    12551265{ 
    1256     enum PROT protection = PROTpublic; 
    12571266    BaseClasses *baseclasses = new BaseClasses(); 
    12581267 
    12591268    for (; 1; nextToken()) 
    12601269    { 
     1270    enum PROT protection = PROTpublic; 
    12611271    switch (token.value) 
    12621272    { 
    1263         case TOKidentifier: 
    1264         break; 
    12651273        case TOKprivate: 
    12661274        protection = PROTprivate; 
    1267         continue; 
     1275        nextToken(); 
     1276        break; 
    12681277        case TOKpackage: 
    12691278        protection = PROTpackage; 
    1270         continue; 
     1279        nextToken(); 
     1280        break; 
    12711281        case TOKprotected: 
    12721282        protection = PROTprotected; 
    1273         continue; 
     1283        nextToken(); 
     1284        break; 
    12741285        case TOKpublic: 
    12751286        protection = PROTpublic; 
    1276         continue; 
    1277         default: 
    1278         error("base classes expected instead of %s", token.toChars()); 
    1279         return NULL; 
    1280     } 
    1281     BaseClass *b = new BaseClass(parseBasicType(), protection); 
    1282     baseclasses->push(b); 
    1283     if (token.value != TOKcomma) 
    1284         break; 
    1285     protection = PROTpublic; 
     1287        nextToken(); 
     1288        break; 
     1289    } 
     1290    if (token.value == TOKidentifier) 
     1291    { 
     1292        BaseClass *b = new BaseClass(parseBasicType(), protection); 
     1293        baseclasses->push(b); 
     1294        if (token.value != TOKcomma) 
     1295        break; 
     1296    } 
     1297    else 
     1298    { 
     1299        error("base classes expected instead of %s", token.toChars()); 
     1300        return NULL; 
     1301    } 
    12861302    } 
    12871303    return baseclasses; 
    …… 
    13421358TemplateParameters *Parser::parseTemplateParameterList(int flag) 
    13431359{ 
    1344     TemplateParameters *tpl; 
     1360    TemplateParameters *tpl = new TemplateParameters(); 
    13451361 
    13461362    if (!flag && token.value != TOKlparen) 
    …… 
    13481364    goto Lerr; 
    13491365    } 
    1350     tpl = new TemplateParameters(); 
    13511366    nextToken(); 
    13521367 
    …… 
    14481463        { 
    14491464            error("no identifier for template value parameter"); 
    1450             goto Lerr; 
     1465            tp_ident = new Identifier("error", TOKidentifier); 
    14511466        } 
    14521467        if (token.value == TOKcolon)    // : CondExpression 
    …… 
    14691484    } 
    14701485    check(TOKrparen); 
     1486Lerr: 
    14711487    return tpl; 
    1472  
    1473 Lerr: 
    1474     return NULL; 
    14751488} 
    14761489 

  • branches/dmdfe-2.0/statement.c

    r880 r881  
    11751175        Initializer *ie = new ExpInitializer(0, new IntegerExp(k)); 
    11761176        VarDeclaration *var = new VarDeclaration(loc, arg->type, arg->ident, ie); 
    1177         var->storage_class |= STCconst; 
     1177        var->storage_class |= STCmanifest; 
    11781178        DeclarationExp *de = new DeclarationExp(loc, var); 
    11791179        st->push(new ExpStatement(loc, de)); 
    …… 
    21282128    condition->checkIntegral(); 
    21292129    } 
     2130    condition = condition->optimize(WANTvalue); 
    21302131 
    21312132    sc = sc->push(); 

  • branches/dmdfe-2.0/template.c

    r880 r881  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    15901590        goto Lnomatch; 
    15911591 
     1592    if (tempinst->tiargs->dim != tp->tempinst->tiargs->dim) 
     1593        goto Lnomatch; 
     1594 
    15921595    for (int i = 0; i < tempinst->tiargs->dim; i++) 
    15931596    { 
    1594         //printf("test: [%d]\n", i); 
     1597        //printf("\ttest: tempinst->tiargs[%d]\n", i); 
    15951598        Object *o1 = (Object *)tempinst->tiargs->data[i]; 
    15961599        Object *o2 = (Object *)tp->tempinst->tiargs->data[i]; 
    …… 
    19371940    if (!ta) 
    19381941    { 
     1942    //printf("test1 %s %p %p %p\n", oarg->toChars(), isExpression(oarg), isDsymbol(oarg), isTuple(oarg)); 
    19391943    goto Lnomatch; 
    19401944    } 
    …… 
    28762880    int dosemantic3 = 0; 
    28772881    {   Array *a; 
    2878     int i; 
    2879  
    2880     if (sc->scopesym && sc->scopesym->members && !sc->scopesym->isTemplateMixin()) 
    2881     { 
    2882         //printf("\t1: adding to %s %s\n", sc->scopesym->kind(), sc->scopesym->toChars()); 
    2883         a = sc->scopesym->members; 
     2882 
     2883    Scope *scx = sc; 
     2884#if 0 
     2885    for (scx = sc; scx; scx = scx->enclosing) 
     2886        if (scx->scopesym) 
     2887        break; 
     2888#endif 
     2889 
     2890    //if (scx && scx->scopesym) printf("3: scx is %s %s\n", scx->scopesym->kind(), scx->scopesym->toChars()); 
     2891    if (scx && scx->scopesym && scx->scopesym->members && !scx->scopesym->isTemplateMixin()) 
     2892    { 
     2893        //printf("\t1: adding to %s %s\n", scx->scopesym->kind(), scx->scopesym->toChars()); 
     2894        a = scx->scopesym->members; 
    28842895    } 
    28852896    else 
    28862897    {   Module *m = sc->module->importedFrom; 
    2887         //printf("\t2: adding to module %s\n", m->toChars()); 
     2898        //printf("\t2: adding to module %s instead of module %s\n", m->toChars(), sc->module->toChars()); 
    28882899        a = m->members; 
    28892900        if (m->semanticdone >= 3) 
    28902901        dosemantic3 = 1; 
    28912902    } 
    2892     for (i = 0; 1; i++) 
     2903    for (int i = 0; 1; i++) 
    28932904    { 
    28942905        if (i == a->dim) 
    …… 
    31333144        ea = ea->optimize(WANTvalue | WANTinterpret); 
    31343145        tiargs->data[j] = ea; 
     3146        if (ea->op == TOKtype) 
     3147        tiargs->data[j] = ea->type; 
    31353148    } 
    31363149    else if (sa) 
    …… 
    34173430        Declaration *d = sa->isDeclaration(); 
    34183431        if (d && !d->isDataseg() && 
     3432        !(d->storage_class & STCmanifest) && 
    34193433        (!d->isFuncDeclaration() || d->isFuncDeclaration()->isNested()) && 
    34203434        !isTemplateMixin()) 

  • branches/dmdfe-2.0/toir.c

    r838 r881  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    103103     * a nested function from its enclosing function. 
    104104     */ 
     105#if V2 
    105106    if (irs->sclosure) 
    106107        ethis = el_var(irs->sclosure); 
    107     else if (irs->sthis) 
     108    else 
     109#endif 
     110    if (irs->sthis) 
    108111    {   // We have a 'this' pointer for the current function 
    109112        ethis = el_var(irs->sthis); 
    …… 
    189192             */ 
    190193            ClassDeclaration *cd = s->isClassDeclaration(); 
    191             assert(cd); 
     194            if (!cd) 
     195            goto Lnoframe; 
    192196            if (//cd->baseClass == fd || 
    193197            fd->isClassDeclaration() && 
    …… 
    196200            if (!cd->isNested() || !cd->vthis) 
    197201            { 
     202              Lnoframe: 
    198203            irs->getFunc()->error(loc, "cannot get frame pointer to %s", fd->toChars()); 
    199204            return el_long(TYnptr, 0);  // error recovery 
    …… 
    394399 */ 
    395400 
     401#if V2 
     402 
    396403void FuncDeclaration::buildClosure(IRState *irs) 
    397404{ 
    …… 
    477484} 
    478485 
    479  
     486#endif 
     487 

  • branches/dmdfe-2.0/toobj.c

    r880 r881  
    967967    if (/*protection == PROTprivate ||*/ 
    968968        !parent || parent->ident == NULL || parent->isFuncDeclaration()) 
     969    { 
    969970        s->Sclass = SCstatic; 
     971    } 
    970972    else 
    971973#endif 

  • branches/dmdfe-2.0/traits.c

    r836 r881  
    232232    else if (ident == Id::getVirtualFunctions) 
    233233    { 
     234printf("test1\n"); 
     235e->dump(0); 
    234236        e = e->semantic(sc); 
     237printf("test2\n"); 
    235238 
    236239        /* Create tuple of virtual function overloads of e