Changeset 183

Show
Ignore:
Timestamp:
07/03/09 03:32:24 (5 years ago)
Author:
braddr
Message:

dmd 2.026

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/access.c

    r169 r183  
    1414 
    1515#include "root.h" 
    16 #include "mem.h" 
     16#include "rmem.h" 
    1717 
    1818#include "enum.h" 
  • trunk/src/aggregate.h

    r177 r183  
    5353    Scope *scope;       // !=NULL means context to use 
    5454 
     55    int isnested;       // !=0 if is nested 
     56    VarDeclaration *vthis;  // 'this' parameter if this aggregate is nested 
     57 
    5558    // Special member functions 
    5659    InvariantDeclaration *inv;      // invariant 
     
    8083    int isDeprecated();     // is aggregate deprecated? 
    8184    FuncDeclaration *buildDtor(Scope *sc); 
     85    int isNested(); 
    8286 
    8387    void emitComment(Scope *sc); 
     
    205209    int isabstract;         // !=0 if abstract class 
    206210 
    207     int isnested;           // !=0 if is nested 
    208     VarDeclaration *vthis;      // 'this' parameter if this class is nested 
    209  
    210211    int inuse;              // to prevent recursive attempts 
    211212 
     
    225226    FuncDeclaration *findFunc(Identifier *ident, TypeFunction *tf); 
    226227    void interfaceSemantic(Scope *sc); 
    227     int isNested(); 
    228228    int isCOMclass(); 
    229229    virtual int isCOMinterface(); 
  • trunk/src/arrayop.c

    r177 r183  
    1212#include <assert.h> 
    1313 
    14 #if _WIN32 || IN_GCC 
    15 #include "mem.h" 
    16 #else 
    17 #include "../root/mem.h" 
    18 #endif 
     14#include "rmem.h" 
    1915 
    2016#include "stringtable.h" 
  • trunk/src/attrib.c

    r182 r183  
    1313#include <assert.h> 
    1414 
    15 #if _WIN32 || IN_GCC 
    16 #include "mem.h" 
    17 #elif linux || __APPLE__ 
    18 #include "../root/mem.h" 
    19 #endif 
     15#include "rmem.h" 
    2016 
    2117#include "init.h" 
  • trunk/src/backend/elfobj.c

    r182 r183  
    1  
    2 //_ elfobj.c    Modified by: Walter Bright 
    3 // Copyright (c) 1984-2009 by Digital Mars, http://www.digitalmars.com 
     1// Copyright (C) ?-1998 by Symantec 
     2// Copyright (C) 2000-2009 by Digital Mars 
    43// All Rights Reserved 
    5 // Written by Walter Bright 
     4// http://www.digitalmars.com 
     5/* 
     6 * This source file is made available for personal use 
     7 * only. The license is in /dmd/src/dmd/backendlicense.txt 
     8 * For any other uses, please contact Digital Mars. 
     9 */ 
     10 
     11 
    612// Output to ELF object files 
    713 
     
    14821488int elf_getsegment2(IDXSEC shtidx, IDXSYM symidx, IDXSEC relidx) 
    14831489{ 
     1490    //printf("SegData = %p\n", SegData); 
    14841491    int seg = ++seg_count; 
    14851492    if (seg_count >= seg_max) 
     
    14871494    seg_max += OB_SEG_INC; 
    14881495    SegData = (seg_data **)mem_realloc(SegData,seg_max * sizeof(seg_data *)); 
    1489     memset(&SegData[seg_count], 0, OB_SEG_INC * sizeof(seg_data *)); 
     1496    memset(&SegData[seg_count], 0, (seg_max - seg_count) * sizeof(seg_data *)); 
    14901497    } 
    14911498    assert(seg_count < seg_max); 
    14921499    if (!SegData[seg]) 
    14931500    {   SegData[seg] = (seg_data *)mem_calloc(sizeof(seg_data)); 
     1501    //printf("test2: SegData[%d] = %p\n", seg, SegData[seg]); 
    14941502    } 
    14951503 
     
    17371745    case mTYman_cpp: 
    17381746    case mTYman_c: 
    1739     case mTYman_java
     1747    case mTYman_d
    17401748    case mTYman_sys: 
    17411749    case 0: 
  • trunk/src/backend/html.c

    r125 r183  
    11 
    2 // Copyright (c) 1999-2006 by Digital Mars 
     2// Copyright (c) 1999-2009 by Digital Mars 
    33// All Rights Reserved 
    44// written by Walter Bright 
     
    1919#include <wchar.h> 
    2020 
    21 #include "mars.h" 
    2221#include "html.h" 
    2322 
     23#if MARS 
    2424#include <assert.h> 
    2525#include "root.h" 
    26 #include "../mars/mars.h" 
     26//#include "../mars/mars.h" 
     27#else 
     28#include "outbuf.h" 
     29#include "msgs2.h" 
     30 
     31extern void html_err(const char *, unsigned, unsigned, ...); 
     32 
     33static char __file__[] = __FILE__;  /* for tassert.h        */ 
     34#include    "tassert.h" 
     35#endif 
     36 
     37#if __GNUC__ 
     38int memicmp(const char *s1, const char *s2, int n); 
     39#if 0 
     40
     41    int result = 0; 
     42 
     43    for (int i = 0; i < n; i++) 
     44    {   char c1 = s1[i]; 
     45    char c2 = s2[i]; 
     46 
     47    result = c1 - c2; 
     48    if (result) 
     49    { 
     50        if ('A' <= c1 && c1 <= 'Z') 
     51        c1 += 'a' - 'A'; 
     52        if ('A' <= c2 && c2 <= 'Z') 
     53        c2 += 'a' - 'A'; 
     54        result = c1 - c2; 
     55        if (result) 
     56        break; 
     57    } 
     58    } 
     59    return result; 
     60
     61#endif 
     62#endif 
    2763 
    2864extern int HtmlNamedEntity(unsigned char *p, int length); 
     
    66102void Html::error(const char *format, ...) 
    67103{ 
    68     if (!global.gag) 
    69     { 
    70     printf("%s(%d) : HTML Error: ", sourcename, linnum); 
    71  
    72     va_list ap; 
    73     va_start(ap, format); 
    74     vprintf(format, ap); 
    75     va_end(ap); 
    76  
    77     printf("\n"); 
    78     fflush(stdout); 
    79     } 
    80  
    81     global.errors++; 
     104    printf("%s(%d) : HTML Error: ", sourcename, linnum); 
     105 
     106    va_list ap; 
     107    va_start(ap, format); 
     108    vprintf(format, ap); 
     109    va_end(ap); 
     110 
     111    printf("\n"); 
     112    fflush(stdout); 
     113 
     114//#if MARS 
     115//    global.errors++; 
     116//#else 
     117    exit(EXIT_FAILURE); 
     118//#endif 
    82119} 
    83120 
     
    87124 */ 
    88125 
     126#if MARS 
    89127void Html::extractCode(OutBuffer *buf) 
     128#else 
     129void Html::extractCode(Outbuffer *buf) 
     130#endif 
    90131{ 
    91132    //printf("Html::extractCode()\n"); 
     
    109150            scanComment(); 
    110151        } 
    111           else if(p[1] == '!' && isCDATAStart()) 
    112           { 
    113               scanCDATA(); 
    114           } 
     152      else if(p[1] == '!' && isCDATAStart()) 
     153      { 
     154          scanCDATA(); 
     155      } 
    115156        else if (p[1] == '/' && istagstart(*skipWhite(p + 2))) 
    116157            skipTag(); 
     
    131172 
    132173            c = charEntity(); 
     174#if MARS 
    133175            buf->writeUTF8(c); 
     176#else 
     177            buf->writeByte(c); 
     178#endif 
    134179        } 
    135180        else 
     
    158203    } 
    159204    buf->writeByte(0);              // ending sentinel 
     205#if SCPP 
     206    //printf("Code is: '%s'\n", buf->toString() + 3); 
     207#endif 
     208#if MARS 
    160209    //printf("D code is: '%s'\n", (char *)buf->data); 
     210#endif 
    161211} 
    162212 
     
    532582         */ 
    533583        linnum++; 
    534         dbuf->writeUTF8('\n'); 
     584        dbuf->writeByte('\n'); 
    535585        p += lineSepLength; 
    536586        continue; 
     
    551601    } 
    552602} 
     603 
    553604 
    554605/******************************************** 
     
    718769} 
    719770 
     771 
  • trunk/src/backend/html.h

    r125 r183  
    11 
    2 // Compiler implementation of the D programming language 
    32// Copyright (c) 1999-2006 by Digital Mars 
    43// All Rights Reserved 
    54// written by Walter Bright 
    6 // http://www.digitalmars.com 
     5// www.digitalmars.com 
    76// License for redistribution is by either the Artistic License 
    87// in artistic.txt, or the GNU General Public License in gnu.txt. 
    98// See the included readme.txt for details. 
    109 
    11 #ifndef DMD_HTML_H 
    12 #define DMD_HTML_H 1 
    1310 
     11#if MARS 
    1412struct OutBuffer; 
     13#else 
     14struct Outbuffer; 
     15#endif 
    1516 
    1617struct Html 
     
    2223    unsigned char *p;       // current character 
    2324    unsigned linnum;        // current line number 
     25#if MARS 
    2426    OutBuffer *dbuf;        // code source buffer 
     27#else 
     28    Outbuffer *dbuf;        // code source buffer 
     29#endif 
    2530    int inCode;         // !=0 if in code 
    2631 
     
    2934 
    3035    void error(const char *format, ...); 
     36#if MARS 
    3137    void extractCode(OutBuffer *buf); 
     38#else 
     39    void extractCode(Outbuffer *buf); 
     40#endif 
    3241    void skipTag(); 
    3342    void skipString(); 
     
    4049    static int namedEntity(unsigned char *p, int length); 
    4150}; 
    42  
    43 #endif 
  • trunk/src/backend/machobj.c

    r182 r183  
    11 
    2 //_ machobj.c   Modified by: Walter Bright 
    3 // Copyright (c) 2009 by Digital Mars, http://www.digitalmars.com 
     2// Copyright (c) 2009 by Digital Mars 
    43// All Rights Reserved 
    5 // Written by Walter Bright 
    6 // Output to Mach-O object files 
     4// written by Walter Bright 
     5// http://www.digitalmars.com 
     6// License for redistribution is by either the Artistic License 
     7// in artistic.txt, or the GNU General Public License in gnu.txt. 
     8// See the included readme.txt for details. 
     9 
    710 
    811#if SCPP || MARS 
     
    14251428    seg_max += 10; 
    14261429    SegData = (seg_data **)mem_realloc(SegData,seg_max * sizeof(seg_data *)); 
    1427     memset(&SegData[seg_count], 0, 10 * sizeof(seg_data *)); 
     1430    memset(&SegData[seg_count], 0, (seg_max - seg_count) * sizeof(seg_data *)); 
    14281431    } 
    14291432    assert(seg_count < seg_max); 
     
    16261629        } 
    16271630    case mTYman_cpp: 
    1628     case mTYman_java
     1631    case mTYman_d
    16291632    case mTYman_sys: 
    16301633    case 0: 
  • trunk/src/builtin.c

    r163 r183  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2009 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
     
    2424#include "module.h" 
    2525 
     26#if V2 
     27 
    2628/********************************** 
    2729 * Determine if function is a builtin one. 
     
    2931enum BUILTIN FuncDeclaration::isBuiltin() 
    3032{ 
    31     static const char FeZe[] = "FeZe"; // real function(real) 
     33    static const char FeZe[] = "FNaNbeZe"; // pure nothrow real function(real) 
    3234 
    3335    //printf("FuncDeclaration::isBuiltin() %s\n", toChars()); 
     
    4143        !parent->parent->parent) 
    4244        { 
     45        //printf("deco = %s\n", type->deco); 
    4346        if (strcmp(type->deco, FeZe) == 0) 
    4447        { 
     
    5558            //printf("builtin = %d\n", builtin); 
    5659        } 
     60        else if (strcmp(type->deco, "FNaNbdZd") == 0 || 
     61             strcmp(type->deco, "FNaNbfZf") == 0) 
     62            builtin = BUILTINsqrt; 
    5763        } 
    5864    } 
     
    101107    return e; 
    102108} 
     109 
     110#endif 
  • trunk/src/cast.c

    r181 r183  
    1111#include <assert.h> 
    1212 
    13 #if _WIN32 || IN_GCC 
    14 #include "mem.h" 
    15 #else 
    16 #include "../root/mem.h" 
    17 #endif 
     13#include "rmem.h" 
    1814 
    1915#include "expression.h" 
     
    6258        else 
    6359        { 
    64         fprintf(stdmsg, "warning - "); 
    65         error("implicit conversion of expression (%s) of type %s to %s can cause loss of data", 
     60        warning("implicit conversion of expression (%s) of type %s to %s can cause loss of data", 
    6661            toChars(), type->toChars(), t->toChars()); 
    6762        } 
     
    17261721} 
    17271722 
     1723/*********************************** 
     1724 * See if both types are arrays that can be compared 
     1725 * for equality. Return !=0 if so. 
     1726 * If they are arrays, but incompatible, issue error. 
     1727 * This is to enable comparing things like an immutable 
     1728 * array with a mutable one. 
     1729 */ 
     1730 
     1731int arrayTypeCompatible(Loc loc, Type *t1, Type *t2) 
     1732{ 
     1733    t1 = t1->toBasetype(); 
     1734    t2 = t2->toBasetype(); 
     1735 
     1736    if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && 
     1737    (t2->ty == Tarray || t2->ty == Tsarray || t2->ty == Tpointer)) 
     1738    { 
     1739    if (t1->nextOf()->implicitConvTo(t2->nextOf()) < MATCHconst && 
     1740        t2->nextOf()->implicitConvTo(t1->nextOf()) < MATCHconst && 
     1741        (t1->nextOf()->ty != Tvoid && t2->nextOf()->ty != Tvoid)) 
     1742    { 
     1743        error("array equality comparison type mismatch, %s vs %s", t1->toChars(), t2->toChars()); 
     1744    } 
     1745    return 1; 
     1746    } 
     1747    return 0; 
     1748} 
  • trunk/src/class.c

    r180 r183  
    1414 
    1515#include "root.h" 
    16 #include "mem.h" 
     16#include "rmem.h" 
    1717 
    1818#include "enum.h" 
     
    189189    isauto = 0; 
    190190    isabstract = 0; 
    191     isnested = 0; 
    192     vthis = NULL; 
    193191    inuse = 0; 
    194192} 
     
    507505        if (s) 
    508506        { 
    509         ClassDeclaration *cd = s->isClassDeclaration(); 
     507        AggregateDeclaration *ad = s->isClassDeclaration(); 
    510508        FuncDeclaration *fd = s->isFuncDeclaration(); 
    511509 
    512510 
    513         if (cd || fd) 
     511        if (ad || fd) 
    514512        {   isnested = 1; 
    515513            Type *t; 
    516             if (cd) 
    517             t = cd->type; 
     514            if (ad) 
     515            t = ad->handle; 
    518516            else if (fd) 
    519517            {   AggregateDeclaration *ad = fd->isMember2(); 
     
    522520            else 
    523521            { 
    524                 t = new TypePointer(Type::tvoid); 
    525                 t = t->semantic(0, sc); 
     522                t = Type::tvoidptr; 
    526523            } 
    527524            } 
    528525            else 
    529526            assert(0); 
     527            if (t->ty == Tstruct)   // ref to struct 
     528            t = Type::tvoidptr; 
    530529            assert(!vthis); 
    531530            vthis = new ThisDeclaration(t); 
     
    886885    for (size_t i = 0; i < vtbl->dim; i++) 
    887886    { 
    888         FuncDeclaration *fd = (FuncDeclaration *)vtbl->data[i]; 
     887        FuncDeclaration *fd = ((Dsymbol*)vtbl->data[i])->isFuncDeclaration(); 
     888        if (!fd) 
     889        continue;       // the first entry might be a ClassInfo 
    889890 
    890891        //printf("\t[%d] = %s\n", i, fd->toChars()); 
     
    971972} 
    972973 
    973  
    974 /**************************************** 
    975  * Returns !=0 if there's an extra member which is the 'this' 
    976  * pointer to the enclosing context (enclosing class or function) 
    977  */ 
    978  
    979 int ClassDeclaration::isNested() 
    980 { 
    981     return isnested; 
    982 } 
    983974 
    984975/**************************************** 
  • trunk/src/clone.c

    r179 r183  
    4848    VarDeclaration *v = s->isVarDeclaration(); 
    4949    assert(v && v->storage_class & STCfield); 
     50    if (v->storage_class & STCref) 
     51        continue; 
    5052    Type *tv = v->type->toBasetype(); 
    5153    while (tv->ty == Tsarray) 
     
    265267    VarDeclaration *v = s->isVarDeclaration(); 
    266268    assert(v && v->storage_class & STCfield); 
     269    if (v->storage_class & STCref) 
     270        continue; 
    267271    Type *tv = v->type->toBasetype(); 
    268272    size_t dim = 1; 
     
    360364    VarDeclaration *v = s->isVarDeclaration(); 
    361365    assert(v && v->storage_class & STCfield); 
     366    if (v->storage_class & STCref) 
     367        continue; 
    362368    Type *tv = v->type->toBasetype(); 
    363369    size_t dim = 1; 
  • trunk/src/constfold.c

    r178 r183  
    1818#endif 
    1919 
    20 #include "mem.h" 
     20#include "rmem.h" 
    2121#include "root.h" 
    2222 
  • trunk/src/declaration.c

    r181 r183  
    457457    goto L2;            // it's a symbolic alias 
    458458 
    459     //printf("alias type is %s\n", type->toChars()); 
    460     type->resolve(loc, sc, &e, &t, &s); 
     459    if (storage_class & STCref) 
     460    {   // For 'ref' to be attached to function types, and picked 
     461    // up by Type::resolve(), it has to go into sc. 
     462    sc = sc->push(); 
     463    sc->stc |= STCref; 
     464    type->resolve(loc, sc, &e, &t, &s); 
     465    sc = sc->pop(); 
     466    } 
     467    else 
     468    type->resolve(loc, sc, &e, &t, &s); 
    461469    if (s) 
    462470    { 
     
    858866    } 
    859867 
    860     if ((storage_class & (STCref | STCparameter | STCforeach)) == STCref) 
     868    if ((storage_class & (STCref | STCparameter | STCforeach)) == STCref && 
     869    ident != Id::This) 
     870    { 
    861871    error("only parameters or foreach declarations can be ref"); 
     872    } 
    862873 
    863874    if (type->isauto() && !noauto) 
     
    904915        e1 = new VarExp(loc, this); 
    905916        e = new AssignExp(loc, e1, e); 
     917        e->op = TOKconstruct; 
    906918        e->type = e1->type;     // don't type check this, it would fail 
    907919        init = new ExpInitializer(loc, e); 
     
    16561668} 
    16571669 
    1658  
  • trunk/src/declaration.h

    r180 r183  
    438438    ThisDeclaration(Type *t); 
    439439    Dsymbol *syntaxCopy(Dsymbol *); 
     440    ThisDeclaration *isThisDeclaration() { return this; } 
    440441}; 
    441442 
  • trunk/src/doc.c

    r182 r183  
    1717#include <assert.h> 
    1818 
    19 #ifdef IN_GCC 
    20 #include "mem.h" 
    21 #else 
    22 #if _WIN32 
    23 #include "..\root\mem.h" 
    24 #elif linux || __APPLE__ 
    25 #include "../root/mem.h" 
    26 #else 
    27 #error "fix this" 
    28 #endif 
    29 #endif 
    30  
     19#include "rmem.h" 
    3120#include "root.h" 
    3221 
  • trunk/src/dsymbol.c

    r180 r183  
    1313#include <assert.h> 
    1414 
    15 #include "mem.h" 
     15#include "rmem.h" 
    1616 
    1717#include "mars.h" 
     
    10071007 
    10081008    if (td) 
    1009     { 
     1009    {   /* $ gives the number of elements in the tuple 
     1010         */ 
    10101011        VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL); 
    10111012        Expression *e = new IntegerExp(0, td->objects->dim, Type::tsize_t); 
     
    10171018 
    10181019    if (type) 
    1019     { 
     1020    {   /* $ gives the number of type entries in the type tuple 
     1021         */ 
    10201022        VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL); 
    10211023        Expression *e = new IntegerExp(0, type->arguments->dim, Type::tsize_t); 
     
    10271029 
    10281030    if (exp->op == TOKindex) 
    1029     { 
     1031    {   /* array[index] where index is some function of $ 
     1032         */ 
    10301033        IndexExp *ie = (IndexExp *)exp; 
    10311034 
     
    10341037    } 
    10351038    else if (exp->op == TOKslice) 
    1036     { 
     1039    {   /* array[lwr .. upr] where lwr or upr is some function of $ 
     1040         */ 
    10371041        SliceExp *se = (SliceExp *)exp; 
    10381042 
     
    10411045    } 
    10421046    else 
     1047        /* Didn't find $, look in enclosing scope(s). 
     1048         */ 
    10431049        return NULL; 
    10441050 
     1051    /* If we are indexing into an array that is really a type 
     1052     * tuple, rewrite this as an index into a type tuple and 
     1053     * try again. 
     1054     */ 
    10451055    if (ce->op == TOKtype) 
    10461056    { 
     
    10521062    } 
    10531063 
    1054     if (!*pvar) 
    1055     { 
     1064    /* *pvar is lazily initialized, so if we refer to $ 
     1065     * multiple times, it gets set only once. 
     1066     */ 
     1067    if (!*pvar)     // if not already initialized 
     1068    {   /* Create variable v and set it to the value of $, 
     1069         * which will be a constant. 
     1070         */ 
    10561071        VarDeclaration *v = new VarDeclaration(loc, Type::tsize_t, Id::dollar, NULL); 
    10571072 
  • trunk/src/dsymbol.h

    r179 r183  
    2626struct DsymbolTable; 
    2727struct Declaration; 
     28struct ThisDeclaration; 
    2829struct TupleDeclaration; 
    2930struct TypedefDeclaration; 
     
    182183    virtual TemplateMixin *isTemplateMixin() { return NULL; } 
    183184    virtual Declaration *isDeclaration() { return NULL; } 
     185    virtual ThisDeclaration *isThisDeclaration() { return NULL; } 
    184186    virtual TupleDeclaration *isTupleDeclaration() { return NULL; } 
    185187    virtual TypedefDeclaration *isTypedefDeclaration() { return NULL; } 
  • trunk/src/e2ir.c

    r182 r183  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2008 by Digital Mars 
     3// Copyright (c) 1999-2009 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
     
    2626#include    "template.h" 
    2727 
    28 #if _WIN32 
    29 #include    "..\tk\mem.h"   // for mem_malloc 
    30 #elif linux || __APPLE__ 
    31 #include    "../tk/mem.h"   // for mem_malloc 
    32 #endif 
     28#include    "mem.h" // for tk/mem_malloc 
    3329 
    3430#include    "cc.h" 
     
    248244 
    249245    tyret = tret->totym(); 
     246 
    250247 
    251248    // Look for intrinsic functions 
     
    15331530         *  *(ey + cd.vthis.offset) = this; 
    15341531         */ 
    1535         elem *ethis; 
    1536         FuncDeclaration *thisfd = irs->getFunc(); 
    1537         int offset = 0; 
    1538         Dsymbol *cdp = cd->toParent2(); // class/func we're nested in 
    1539  
    1540         if (cdp == thisfd) 
    1541         {   /* Class we're new'ing is a local class in this function: 
    1542          *  void thisfd() { class cd { } } 
    1543          */ 
    1544         if (irs->sclosure) 
    1545             ethis = el_var(irs->sclosure); 
    1546         else if (irs->sthis) 
    1547         { 
    1548 #if V2 
    1549             if (thisfd->closureVars.dim) 
    1550 #else 
    1551             if (thisfd->nestedFrameRef) 
    1552 #endif 
    1553             { 
    1554             ethis = el_ptr(irs->sthis); 
    1555             } 
    1556             else 
    1557             ethis = el_var(irs->sthis); 
    1558         } 
    1559         else 
    1560         { 
    1561             ethis = el_long(TYnptr, 0); 
    1562 #if V2 
    1563             if (thisfd->closureVars.dim) 
    1564 #else 
    1565             if (thisfd->nestedFrameRef) 
    1566 #endif 
    1567             { 
    1568             ethis->Eoper = OPframeptr; 
    1569             } 
    1570         } 
    1571         } 
    1572         else if (thisfd->vthis && 
    1573           (cdp == thisfd->toParent2() || 
    1574            (cdp->isClassDeclaration() && 
    1575             cdp->isClassDeclaration()->isBaseOf(thisfd->toParent2()->isClassDeclaration(), &offset) 
    1576            ) 
    1577           ) 
    1578         ) 
    1579         {   /* Class we're new'ing is at the same level as thisfd 
    1580          */ 
    1581         assert(offset == 0);    // BUG: should handle this case 
    1582         ethis = el_var(irs->sthis); 
    1583         } 
    1584         else 
    1585         { 
    1586         ethis = getEthis(loc, irs, cd->toParent2()); 
    1587         ethis = el_una(OPaddr, TYnptr, ethis); 
    1588         } 
    1589  
    1590         ey = el_bin(OPadd, TYnptr, ey, el_long(TYint, cd->vthis->offset)); 
    1591         ey = el_una(OPind, TYnptr, ey); 
    1592         ey = el_bin(OPeq, TYnptr, ey, ethis); 
    1593  
     1532        ey = setEthis(loc, irs, ey, cd); 
    15941533    } 
    15951534 
     
    16311570        ei = el_var(si); 
    16321571 
    1633         if (member) 
     1572        if (cd->isNested()) 
     1573        { 
     1574        ey = el_same(&ex); 
     1575        ez = el_copytree(ey); 
     1576        } 
     1577        else if (member) 
    16341578        ez = el_same(&ex); 
    1635         else 
     1579 
     1580        if (!member) 
    16361581        {   /* Statically intialize with default initializer 
    16371582         */ 
     
    16611606        ectype = NULL; 
    16621607 
    1663         if (member) 
     1608        if (cd->isNested()) 
     1609        { 
     1610        ey = el_same(&ex); 
     1611        ez = el_copytree(ey); 
     1612        } 
     1613        else if (member) 
    16641614        ez = el_same(&ex); 
    16651615//elem_print(ex); 
    16661616//elem_print(ey); 
    16671617//elem_print(ez); 
     1618    } 
     1619 
     1620    if (cd->isNested()) 
     1621    {   /* Initialize cd->vthis: 
     1622         *  *(ey + cd.vthis.offset) = this; 
     1623         */ 
     1624        ey = setEthis(loc, irs, ey, cd); 
    16681625    } 
    16691626 
     
    27542711    if (s->storage_class & STCref) 
    27552712    { 
     2713#if 0 
    27562714        Expression *ae = e2->addressOf(NULL); 
    27572715        e = ae->toElem(irs); 
     2716#else 
     2717        e = e2->toElem(irs); 
     2718        e = addressElem(e, e2->type); 
     2719#endif 
    27582720        elem *es = el_var(s->toSymbol()); 
    27592721        es->Ety = TYnptr; 
    27602722        e = el_bin(OPeq, TYnptr, es, e); 
     2723// BUG: type is struct, and e2 is TOKint64 
    27612724        goto Lret; 
    27622725    } 
     
    27852748    } 
    27862749#endif 
     2750//printf("test1 %d\n", op); 
     2751//if (op == TOKconstruct) printf("construct\n"); 
    27872752    if (t1b->ty == Tstruct) 
    2788     { 
     2753    {   elem *eleft = e1->toElem(irs); 
     2754 
    27892755    if (e2->op == TOKint64) 
    27902756    {   /* Implement: 
     
    27932759         *  memset(&struct, 0, struct.sizeof) 
    27942760         */ 
    2795         elem *el = e1->toElem(irs); 
    2796         elem *enbytes = el_long(TYint, e1->type->size()); 
     2761        elem *ey = NULL; 
     2762        int sz = e1->type->size(); 
     2763        StructDeclaration *sd = ((TypeStruct *)t1b)->sym; 
     2764        if (sd->isnested && op == TOKconstruct) 
     2765        { 
     2766        ey = el_una(OPaddr, TYnptr, eleft); 
     2767        eleft = el_same(&ey); 
     2768        ey = setEthis(loc, irs, ey, sd); 
     2769        sz = sd->vthis->offset; 
     2770        } 
     2771 
     2772        elem *el = eleft; 
     2773        elem *enbytes = el_long(TYint, sz); 
    27972774        elem *evalue = el_long(TYint, 0); 
    27982775 
    2799         el = el_una(OPaddr, TYnptr, el); 
     2776        if (!(sd->isnested && op == TOKconstruct)) 
     2777        el = el_una(OPaddr, TYnptr, el); 
    28002778        e = el_param(enbytes, evalue); 
    28012779        e = el_bin(OPmemset,TYnptr,el,e); 
     2780        e = el_combine(ey, e); 
    28022781        el_setLoc(e, loc); 
    28032782        //e = el_una(OPind, TYstruct, e); 
     
    28052784    else 
    28062785    { 
    2807         elem *e1; 
    2808         elem *e2; 
    2809         tym_t tym; 
    2810  
    28112786        //printf("toElemBin() '%s'\n", toChars()); 
    28122787 
    2813         tym = type->totym(); 
    2814  
    2815         e1 = this->e1->toElem(irs)
     2788        tym_t tym = type->totym(); 
     2789 
     2790        elem *e1 = eleft
    28162791        elem *ex = e1; 
    28172792        if (e1->Eoper == OPind) 
     
    28382813        else 
    28392814        { 
    2840         e2 = this->e2->toElem(irs); 
     2815        elem *e2 = this->e2->toElem(irs); 
    28412816        e = el_bin(OPstreq,tym,e1,e2); 
    28422817        e->Enumbytes = this->e1->type->size(); 
     
    39853960    case X(Tfloat80,Tuns32): 
    39863961    case X(Tfloat80,Tint64): 
    3987     case X(Tfloat80,Tuns64): 
    39883962    case X(Tfloat80,Tfloat32): e = el_una(OPld_d, TYdouble, e); 
    39893963                   fty = Tfloat64; 
    39903964                   goto Lagain; 
     3965    case X(Tfloat80,Tuns64): 
     3966                   eop = OPld_u64; goto Leop; 
    39913967    case X(Tfloat80,Tfloat64): eop = OPld_d; goto Leop; 
    39923968    case X(Tfloat80,Timaginary32): goto Lzero; 
     
    46384614        VarDeclaration *v = s->isVarDeclaration(); 
    46394615        assert(v); 
     4616        assert(!v->isThisDeclaration()); 
    46404617 
    46414618        elem *e1; 
     
    47314708    } 
    47324709 
     4710    if (sd->isnested) 
     4711    {   // Initialize the hidden 'this' pointer 
     4712    assert(sd->fields.dim); 
     4713    Dsymbol *s = (Dsymbol *)sd->fields.data[sd->fields.dim - 1]; 
     4714    ThisDeclaration *v = s->isThisDeclaration(); 
     4715    assert(v); 
     4716 
     4717    elem *e1; 
     4718    if (tybasic(stmp->Stype->Tty) == TYnptr) 
     4719    {   e1 = el_var(stmp); 
     4720        e1->EV.sp.Voffset = soffset; 
     4721    } 
     4722    else 
     4723    {   e1 = el_ptr(stmp); 
     4724        if (soffset) 
     4725        e1 = el_bin(OPadd, TYnptr, e1, el_long(TYsize_t, soffset)); 
     4726    } 
     4727    e1 = el_bin(OPadd, TYnptr, e1, el_long(TYsize_t, v->offset)); 
     4728    e1 = setEthis(loc, irs, e1, sd); 
     4729 
     4730    e = el_combine(e, e1); 
     4731    } 
     4732 
    47334733    elem *ev = el_var(stmp); 
    47344734    ev->Enumbytes = sd->structsize; 
  • trunk/src/expression.c

    r182 r183  
    3333#endif 
    3434 
    35 #if IN_GCC 
    36 #include "mem.h" 
    37 #elif _WIN32 
    38 #include "..\root\mem.h" 
    39 #elif linux || __APPLE__ 
    40 #include "../root/mem.h" 
    41 #endif 
     35#include "rmem.h" 
    4236 
    4337//#include "port.h" 
     
    951945} 
    952946 
     947void Expression::warning(const char *format, ...) 
     948{ 
     949    if (global.params.warnings && !global.gag) 
     950    { 
     951    fprintf(stdmsg, "warning - "); 
     952    va_list ap; 
     953    va_start(ap, format); 
     954    ::verror(loc, format, ap); 
     955    va_end( ap ); 
     956    } 
     957} 
     958 
    953959void Expression::rvalue() 
    954960{ 
     
    30733079Expression *StructLiteralExp::semantic(Scope *sc) 
    30743080{   Expression *e; 
     3081    int nfields = sd->fields.dim - sd->isnested; 
    30753082 
    30763083#if LOGSEMANTIC 
     
    30983105        error("%s has no value", e->toChars()); 
    30993106    e = resolveProperties(sc, e); 
    3100     if (i >= sd->fields.dim
     3107    if (i >= nfields
    31013108    {   error("more initializers than fields of %s", sd->toChars()); 
    31023109        break; 
     
    31243131    /* Fill out remainder of elements[] with default initializers for fields[] 
    31253132     */ 
    3126     for (size_t i = elements->dim; i < sd->fields.dim; i++) 
     3133    for (size_t i = elements->dim; i < nfields; i++) 
    31273134    {   Dsymbol *s = (Dsymbol *)sd->fields.data[i]; 
    31283135    VarDeclaration *v = s->isVarDeclaration(); 
    31293136    assert(v); 
     3137    assert(!v->isThisDeclaration()); 
    31303138 
    31313139    if (v->offset < offset) 
     
    46994707    if (m == MATCHnomatch || 
    47004708        (m != MATCHexact && tok == TOKequal)) 
     4709    { 
    47014710        goto Lno; 
     4711    } 
    47024712    else 
    47034713    { 
     
    47414751    { 
    47424752    /* Evaluate to TRUE if targ matches tspec 
     4753     * is(targ == tspec) 
     4754     * is(targ : tspec) 
    47434755     */ 
    47444756    tspec = tspec->semantic(loc, sc); 
     
    59705982    int istemp; 
    59715983    Objects *targsi = NULL; // initial list of template arguments 
     5984    TemplateInstance *tierror = NULL; 
    59725985 
    59735986#if LOGSEMANTIC 
     
    60596072        global.errors = errors; 
    60606073        targsi = ti->tiargs; 
     6074        tierror = ti;           // for error reporting 
    60616075        e1 = new IdentifierExp(loc, ti->name); 
    60626076        } 
     
    60856099        global.errors = errors; 
    60866100        targsi = ti->tiargs; 
     6101        tierror = ti;       // for error reporting 
    60876102        e1 = new DotIdExp(loc, se->e1, ti->name); 
    60886103        } 
     
    64846499        f = te->td->deduceFunctionTemplate(sc, loc, targsi, NULL, arguments); 
    64856500        if (!f) 
    6486         {   type = Type::terror; 
     6501        {   if (tierror) 
     6502            tierror->error("errors instantiating template");    // give better error message 
     6503        type = Type::terror; 
    64876504        return this; 
    64886505        } 
     
    66276644int CallExp::isLvalue() 
    66286645{ 
    6629     if (type->toBasetype()->ty == Tstruct) 
    6630   return 1; 
     6646//    if (type->toBasetype()->ty == Tstruct) 
     6647//    return 1; 
    66316648    Type *tb = e1->type->toBasetype(); 
    66326649    if (tb->ty == Tfunction && ((TypeFunction *)tb)->isref) 
     
    74377454    } 
    74387455 
    7439     type = t->nextOf()->arrayOf(); 
     7456    if (t->ty == Tarray) 
     7457    { 
     7458    type = e1->type; 
     7459    } 
     7460    else 
     7461    type = t->nextOf()->arrayOf(); 
    74407462    return e; 
    74417463 
     
    77747796    case Taarray: 
    77757797    {   TypeAArray *taa = (TypeAArray *)t1; 
    7776  
    7777         e2 = e2->implicitCastTo(sc, taa->index);    // type checking 
     7798        if (!arrayTypeCompatible(e2->loc, e2->type, taa->index)) 
     7799        { 
     7800        e2 = e2->implicitCastTo(sc, taa->index);    // type checking 
     7801        } 
    77787802        type = taa->next; 
    77797803        break; 
     
    94669490    TypeAArray *ta = (TypeAArray *)t2b; 
    94679491 
    9468     // Convert key to type of key 
    9469     e1 = e1->implicitCastTo(sc, ta->index); 
     9492    // Special handling for array keys 
     9493    if (!arrayTypeCompatible(e1->loc, e1->type, ta->index)) 
     9494    { 
     9495        // Convert key to type of key 
     9496        e1 = e1->implicitCastTo(sc, ta->index); 
     9497    } 
    94709498 
    94719499    // Return type is pointer to value 
     
    96359663 
    96369664    // Special handling for array comparisons 
    9637     t1 = e1->type->toBasetype(); 
    9638     t2 = e2->type->toBasetype(); 
    9639  
    9640     if ((t1->ty == Tarray || t1->ty == Tsarray || t1->ty == Tpointer) && 
    9641     (t2->ty == Tarray || t2->ty == Tsarray || t2->ty == Tpointer)) 
    9642     { 
    9643     if (t1->nextOf()->implicitConvTo(t2->nextOf()) < MATCHconst && 
    9644         t2->nextOf()->implicitConvTo(t1->nextOf()) < MATCHconst && 
    9645         (t1->nextOf()->ty != Tvoid && t2->nextOf()->ty != Tvoid)) 
    9646         error("array equality comparison type mismatch, %s vs %s", t1->toChars(), t2->toChars()); 
    9647     } 
    9648     else 
     9665    if (!arrayTypeCompatible(loc, e1->type, e2->type)) 
    96499666    { 
    96509667    if (e1->type != e2->type && e1->type->isfloating() && e2->type->isfloating()) 
  • trunk/src/expression.h

    r181 r183  
    9090    virtual void dump(int indent); 
    9191    void error(const char *format, ...); 
     92    void warning(const char *format, ...); 
    9293    virtual void rvalue(); 
    9394 
  • trunk/src/func.c

    r182 r183  
    374374 
    375375#if V2 
    376         if (!isOverride() && global.params.warnings
    377             error("overrides base class function %s, but is not marked with 'override'", fdv->toPrettyChars()); 
     376        if (!isOverride()
     377            warning(loc, "overrides base class function %s, but is not marked with 'override'", fdv->toPrettyChars()); 
    378378#endif 
    379379 
     
    11091109            {   Expression *e; 
    11101110 
    1111             if (global.params.warnings) 
    1112             {   fprintf(stdmsg, "warning - "); 
    1113                 error("no return at end of function"); 
    1114             } 
     1111            warning(loc, "no return at end of function"); 
    11151112 
    11161113            if (global.params.useAssert && 
     
    19421939    else 
    19431940    { 
    1944         ClassDeclaration *thiscd = s->isClassDeclaration(); 
     1941        AggregateDeclaration *thiscd = s->isAggregateDeclaration(); 
    19451942        if (thiscd) 
    19461943        {   if (!thiscd->isNested()) 
  • trunk/src/hdrgen.c

    r182 r183  
    2525#endif 
    2626 
    27 #ifdef IN_GCC 
    28 #include "mem.h" 
    29 #else 
    30 #if _WIN32 
    31 #include "..\root\mem.h" 
    32 #elif linux || __APPLE__ 
    33 #include "../root/mem.h" 
    34 #else 
    35 #error "fix this" 
    36 #endif 
    37 #endif 
     27#include "rmem.h" 
    3828 
    3929#include "id.h" 
  • trunk/src/inifile.c

    r182 r183  
    1  
    2 // Copyright (c) 1999-2009 by Digital Mars 
    3 // All Rights Reserved 
    4 // written by Walter Bright 
    5 // http://www.digitalmars.com 
    6  
     1/* 
     2 * Some portions copyright (c) 1994-1995 by Symantec 
     3 * Copyright (c) 1999-2009 by Digital Mars 
     4 * All Rights Reserved 
     5 * http://www.digitalmars.com 
     6 * Written by Walter Bright 
     7 * 
     8 * This source file is made available for personal use 
     9 * only. The license is in /dmd/src/dmd/backendlicense.txt 
     10 * For any other uses, please contact Digital Mars. 
     11 */ 
    712 
    813#include    <stdio.h> 
     
    1621 
    1722#include    "root.h" 
    18 #include    "mem.h" 
     23#include    "rmem.h" 
    1924 
    2025#define LOG 0 
  • trunk/src/interpret.c

    r180 r183  
    1313#include <assert.h> 
    1414 
    15 #include "mem.h" 
     15#include "rmem.h" 
    1616 
    1717#include "statement.h" 
  • trunk/src/lexer.c

    r182 r183  
    2525#endif 
    2626#ifdef IN_GCC 
    27  
    2827#include <time.h> 
    29 #include "mem.h" 
    30  
    3128#else 
    32  
    3329#if __GNUC__ 
    3430#include <time.h> 
    3531#endif 
    36  
    37 #if _WIN32 
    38 #include "..\root\mem.h" 
    39 #else 
    40 #include "../root/mem.h" 
    41 #endif 
    42 #endif 
     32#endif 
     33 
     34#include "rmem.h" 
    4335 
    4436#include "stringtable.h" 
     
    617609        case '\\':          // escaped string literal 
    618610        {   unsigned c; 
     611        unsigned char *pstart = p; 
    619612 
    620613        stringbuffer.reset(); 
     
    643636        t->postfix = 0; 
    644637        t->value = TOKstring; 
     638        if (!global.params.useDeprecated) 
     639            error("Escape String literal %.*s is deprecated, use double quoted string literal \"%.*s\" instead", p - pstart, pstart, p - pstart, pstart); 
    645640        return; 
    646641        } 
  • trunk/src/libelf.c

    r181 r183  
    1717#include <sys/stat.h> 
    1818 
    19 #include "mem.h" 
     19#include "rmem.h" 
    2020#include "root.h" 
    2121#include "stringtable.h" 
  • trunk/src/libmach.c

    r182 r183  
    3030#include "mach.h" 
    3131 
    32 #include "mem.h" 
     32#include "rmem.h" 
    3333#include "root.h" 
    3434#include "stringtable.h" 
  • trunk/src/link.c

    r182 r183  
    3030#include    "mars.h" 
    3131 
    32 #include    "mem.h" 
     32#include    "rmem.h" 
    3333 
    3434int executecmd(char *cmd, char *args, int useenv); 
  • trunk/src/macro.c

    r182 r183  
    1717#include <assert.h> 
    1818 
    19 #ifdef IN_GCC 
    20 #include "mem.h" 
    21 #else 
    22 #if _WIN32 
    23 #include "..\root\mem.h" 
    24 #elif linux || __APPLE__ 
    25 #include "../root/mem.h" 
    26 #else 
    27 #error "fix this" 
    28 #endif 
    29 #endif 
    30  
     19#include "rmem.h" 
    3120#include "root.h" 
     21 
    3222#include "macro.h" 
    3323 
  • trunk/src/mars.c

    r182 r183  
    2323#endif 
    2424 
    25 #include "mem.h" 
     25#include "rmem.h" 
    2626#include "root.h" 
    2727 
     
    7575    copyright = "Copyright (c) 1999-2009 by Digital Mars"; 
    7676    written = "written by Walter Bright"; 
    77     version = "v2.025"; 
     77    version = "v2.026"; 
    7878    global.structalign = 8; 
    7979 
     
    113113    verror(loc, format, ap); 
    114114    va_end( ap ); 
     115} 
     116 
     117void warning(Loc loc, const char *format, ...) 
     118{ 
     119    if (global.params.warnings && !global.gag) 
     120    { 
     121    fprintf(stdmsg, "warning - "); 
     122    va_list ap; 
     123    va_start(ap, format); 
     124    verror(loc, format, ap); 
     125    va_end( ap ); 
     126    } 
    115127} 
    116128 
     
    236248    int status = EXIT_SUCCESS; 
    237249    int argcstart = argc; 
     250    int setdebuglib = 0; 
    238251 
    239252    // Check for malformed input 
     
    281294    global.params.defaultlibname = "phobos2"; 
    282295#endif 
    283     global.params.debuglibname = global.params.defaultlibname; 
    284296 
    285297    // Predefine version identifiers 
     
    556568        else if (memcmp(p + 1, "debuglib=", 9) == 0) 
    557569        { 
     570        setdebuglib = 1; 
    558571        global.params.debuglibname = p + 1 + 9; 
    559572        } 
     
    631644    } 
    632645 
     646    if (!setdebuglib) 
     647    global.params.debuglibname = global.params.defaultlibname; 
     648 
    633649#if TARGET_OSX 
    634650    global.params.pic = 1; 
  • trunk/src/mars.h

    r182 r183  
    347347}; 
    348348 
     349void warning(Loc loc, const char *format, ...); 
    349350void error(Loc loc, const char *format, ...); 
    350351void verror(Loc loc, const char *format, va_list); 
  • trunk/src/module.c

    r180 r183  
    2121#endif 
    2222 
    23 #include "mem.h" 
     23#include "rmem.h" 
    2424 
    2525#include "mars.h" 
     
    7676    strictlyneedmoduleinfo = 0; 
    7777#endif 
     78    selfimports = 0; 
    7879    insearch = 0; 
    7980    searchCacheIdent = NULL; 
     
    916917        mi->insearch = 1; 
    917918        int r = mi->imports(m); 
    918         mi->insearch = 0; 
    919919        if (r) 
    920920        return r; 
     
    923923    return FALSE; 
    924924} 
     925 
     926/************************************* 
     927 * Return !=0 if module imports itself. 
     928 */ 
     929 
     930int Module::selfImports() 
     931{ 
     932    //printf("Module::selfImports() %s\n", toChars()); 
     933    if (!selfimports) 
     934    { 
     935    for (int i = 0; i < amodules.dim; i++) 
     936    {   Module *mi = (Module *)amodules.data[i]; 
     937        //printf("\t[%d] %s\n", i, mi->toChars()); 
     938        mi->insearch = 0; 
     939    } 
     940 
     941    selfimports = imports(this) + 1; 
     942 
     943    for (int i = 0; i < amodules.dim; i++) 
     944    {   Module *mi = (Module *)amodules.data[i]; 
     945        //printf("\t[%d] %s\n", i, mi->toChars()); 
     946        mi->insearch = 0; 
     947    } 
     948    } 
     949    return selfimports - 1; 
     950} 
     951 
    925952 
    926953/* =========================== ModuleDeclaration ===================== */ 
  • trunk/src/module.h

    r180 r183  
    7373    int strictlyneedmoduleinfo; 
    7474#endif 
     75 
     76    int selfimports;        // 0: don't know, 1: does not, 2: does 
     77    int selfImports();      // returns !=0 if module imports itself 
    7578 
    7679    int insearch; 
  • trunk/src/mtype.c

    r182 r183  
    4040#endif 
    4141 
    42 #include "mem.h" 
     42#include "rmem.h" 
    4343 
    4444#include "dsymbol.h" 
     
    13831383    ::verror(loc, format, ap); 
    13841384    va_end( ap ); 
     1385} 
     1386 
     1387void Type::warning(Loc loc, const char *format, ...) 
     1388{ 
     1389    if (global.params.warnings && !global.gag) 
     1390    { 
     1391    fprintf(stdmsg, "warning - "); 
     1392    va_list ap; 
     1393    va_start(ap, format); 
     1394    ::verror(loc, format, ap); 
     1395    va_end( ap ); 
     1396    } 
    13851397} 
    13861398 
     
    26422654        return arg->type; 
    26432655    } 
     2656    case Tstruct: 
     2657    {   TypeStruct *ts = (TypeStruct *)tbn; 
     2658        if (ts->sym->isnested) 
     2659        error(loc, "cannot have array of inner structs %s", ts->toChars()); 
     2660        break; 
     2661    } 
    26442662    case Tfunction: 
    26452663    case Tnone: 
     
    28532871        tn = next = tint32; 
    28542872        break; 
     2873    case Tstruct: 
     2874    {   TypeStruct *ts = (TypeStruct *)tbn; 
     2875        if (ts->sym->isnested) 
     2876        error(loc, "cannot have array of inner structs %s", ts->toChars()); 
     2877        break; 
     2878    } 
    28552879    } 
    28562880    if (tn->isauto()) 
     
    36693693void TypeFunction::toCBuffer(OutBuffer *buf, Identifier *ident, HdrGenState *hgs) 
    36703694{ 
    3671     //printf("TypeFunction::toCBuffer() this = %p %s\n", this, toChars()); 
     3695    //printf("TypeFunction::toCBuffer() this = %p\n", this); 
    36723696    const char *p = NULL; 
    36733697 
     
    37223746void TypeFunction::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod) 
    37233747{ 
    3724     //printf("TypeFunction::toCBuffer2() this = %p %s\n", this, toChars()); 
     3748    //printf("TypeFunction::toCBuffer2() this = %p, ref = %d\n", this, isref); 
    37253749    const char *p = NULL; 
    37263750 
     
    50015025    if (!s) 
    50025026    { 
    5003     return getProperty(e->loc, ident); 
     5027    if (ident == Id::max || 
     5028        ident == Id::min || 
     5029        ident == Id::init || 
     5030        ident == Id::stringof || 
     5031        !sym->memtype 
     5032       ) 
     5033    { 
     5034        return getProperty(e->loc, ident); 
     5035    } 
     5036    return sym->memtype->dotExp(sc, e, ident); 
    50045037    } 
    50055038    EnumMember *m = s->isEnumMember(); 
     
    57025735    { 
    57035736    Dsymbol *sm = (Dsymbol *)s->fields.data[i]; 
    5704     if (sm->hasPointers()) 
     5737    Declaration *d = sm->isDeclaration(); 
     5738    if (d->storage_class & STCref || d->hasPointers()) 
    57055739        return TRUE; 
    57065740    } 
  • trunk/src/mtype.h

    r182 r183  
    284284 
    285285    static void error(Loc loc, const char *format, ...); 
     286    static void warning(Loc loc, const char *format, ...); 
    286287 
    287288    // For backend 
     
    812813extern int Tptrdiff_t; 
    813814 
     815int arrayTypeCompatible(Loc loc, Type *t1, Type *t2); 
     816 
    814817#endif /* DMD_MTYPE_H */ 
  • trunk/src/opover.c

    r182 r183  
    2323#endif 
    2424 
    25 #if IN_GCC 
    26 #include "mem.h" 
    27 #elif linux || __APPLE__ 
    28 #include "../root/mem.h" 
    29 #elif _WIN32 
    30 #include "..\root\mem.h" 
    31 #endif 
     25#include "rmem.h" 
    3226 
    3327//#include "port.h" 
  • trunk/src/parse.c

    r181 r183  
    1414#include <assert.h> 
    1515 
    16 #include "mem.h" 
     16#include "rmem.h" 
    1717#include "lexer.h" 
    1818#include "parse.h" 
     
    388388            (tk = peek(&token))->value == TOKlparen && 
    389389            skipParens(tk, &tk) && 
    390             peek(tk)->value == TOKlparen) 
     390            (peek(tk)->value == TOKlparen || 
     391             peek(tk)->value == TOKlcurly) 
     392           ) 
    391393        { 
    392394            a = parseDeclarations(storageClass); 
     
    17491751Objects *Parser::parseTemplateArgumentList2() 
    17501752{ 
     1753    //printf("Parser::parseTemplateArgumentList2()\n"); 
    17511754    Objects *tiargs = new Objects(); 
    17521755    enum TOK endtok = TOKrparen; 
     
    39073910 
    39083911#if V2 
    3909     if ((t->value == TOKconst || t->value == TOKinvariant || token.value == TOKimmutable || token.value == TOKshared) && 
     3912    if ((t->value == TOKconst || 
     3913     t->value == TOKinvariant || 
     3914     t->value == TOKimmutable || 
     3915     t->value == TOKshared) && 
    39103916    peek(t)->value != TOKlparen) 
    39113917    {   /* const type 
     
    39183924 
    39193925    if (!isBasicType(&t)) 
     3926    { 
    39203927    goto Lisnot; 
     3928    } 
    39213929    if (!isDeclarator(&t, &haveId, endtok)) 
    39223930    goto Lisnot; 
     
    40424050        t = peek(t); 
    40434051        if (!isDeclaration(t, 0, TOKrparen, &t)) 
     4052        { 
    40444053        goto Lfalse; 
     4054        } 
    40454055        t = peek(t); 
    40464056        break; 
  • trunk/src/readme.txt

    r5 r183  
    22        The D Programming Language 
    33        Compiler Front End Source 
    4         Copyright (c) 1999-2002, by Digital Mars 
    5         www.digitalmars.com 
     4        Copyright (c) 1999-2009, by Digital Mars 
     5        http://www.digitalmars.com 
    66        All Rights Reserved 
    77 
     
    1010It covers the lexical analysis, parsing, and semantic analysis 
    1111of the D Programming Language defined in the documents at 
    12 www.digitalmars.com/d/ 
    13  
    14 The optimizer, code generator, and object file generator are not part 
    15 of this source, hence the source does not currently constitute a complete, 
    16 compilable program. However, many people have expressed a strong interested 
    17 in producing a D compiler with the GNU compiler sources. This release should 
    18 enable that. 
     12http://www.digitalmars.com/d/ 
    1913 
    2014These sources are free, they are redistributable and modifiable 
     
    2216or the Artistic License (attached as artistic.txt). 
    2317 
     18The optimizer and code generator sources are  
     19covered under a separate license, backendlicense.txt. 
     20 
    2421It does not apply to anything else distributed by Digital Mars, 
    2522including D compiler executables. 
  • trunk/src/root/array.c

    r103 r183  
    3838#include "root.h" 
    3939#include "dchar.h" 
    40 #include "mem.h" 
     40#include "rmem.h" 
    4141 
    4242 
  • trunk/src/root/dchar.c

    r111 r183  
    1515 
    1616#include "dchar.h" 
    17 #include "mem.h" 
     17#include "rmem.h" 
    1818 
    1919#if M_UNICODE 
  • trunk/src/root/lstring.c

    r179 r183  
    1212 
    1313#include "dchar.h" 
    14 #include "mem.h" 
     14#include "rmem.h" 
    1515#include "lstring.h" 
    1616 
  • trunk/src/root/rmem.c

    r182 r183  
    88 
    99#if linux || __APPLE__ || __FreeBSD__ 
    10 #include "../root/mem.h" 
     10#include "../root/rmem.h" 
    1111#else 
    12 #include "mem.h" 
     12#include "rmem.h" 
    1313#endif 
    1414 
  • trunk/src/root/root.c

    r182 r183  
    3737#include "root.h" 
    3838#include "dchar.h" 
    39 #include "mem.h" 
     39#include "rmem.h" 
    4040 
    4141#if 0 //__SC__ //def DEBUG 
  • trunk/src/root/stringtable.c

    r172 r183  
    1414 
    1515#include "root.h" 
    16 #include "mem.h" 
     16#include "rmem.h" 
    1717#include "dchar.h" 
    1818#include "lstring.h" 
  • trunk/src/scope.c

    r169 r183  
    254254            sc->enclosing->search(loc, ident, NULL)) 
    255255        { 
    256             if (global.params.warnings) 
    257             fprintf(stdmsg, "warning - "); 
    258             error(s->loc, "array 'length' hides other 'length' name in outer scope"); 
     256            warning(s->loc, "array 'length' hides other 'length' name in outer scope"); 
    259257        } 
    260258 
  • trunk/src/statement.c

    r182 r183  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2008 by Digital Mars 
     3// Copyright (c) 1999-2009 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
     
    1313#include <assert.h> 
    1414 
    15 #include "mem.h" 
     15#include "rmem.h" 
    1616 
    1717#include "statement.h" 
     
    9595    ::verror(loc, format, ap); 
    9696    va_end( ap ); 
     97} 
     98 
     99void Statement::warning(const char *format, ...) 
     100{ 
     101    if (global.params.warnings && !global.gag) 
     102    { 
     103    fprintf(stdmsg, "warning - "); 
     104    va_list ap; 
     105    va_start(ap, format); 
     106    ::verror(loc, format, ap); 
     107    va_end( ap ); 
     108    } 
    97109} 
    98110 
     
    544556        if (!(result & BEfallthru) && !s->comeFrom()) 
    545557        { 
    546         if (global.params.warnings) 
    547         {   fprintf(stdmsg, "warning - "); 
    548             s->error("statement is not reachable"); 
    549         } 
     558        s->warning("statement is not reachable"); 
    550559        } 
    551560 
     
    10911100    if (body) 
    10921101    {   int r = body->blockExit(); 
    1093     if (r & BEbreak
     1102    if (r & (BEbreak | BEgoto)
    10941103        result |= BEfallthru; 
    1095     result |= r & ~(BEbreak | BEcontinue); 
     1104    result |= r & ~(BEfallthru | BEbreak | BEcontinue); 
    10961105    } 
    10971106    if (increment && increment->canThrow()) 
     
    14531462        Identifier *id = Identifier::generateId("__r"); 
    14541463        VarDeclaration *r = new VarDeclaration(loc, NULL, id, new ExpInitializer(loc, aggr)); 
    1455         r->semantic(sc); 
     1464//      r->semantic(sc); 
     1465//printf("r: %s, init: %s\n", r->toChars(), r->init->toChars()); 
    14561466        Statement *init = new DeclarationStatement(loc, r); 
     1467//printf("init: %s\n", init->toChars()); 
    14571468 
    14581469        // !__r.empty 
     
    14701481        e = new VarExp(loc, r); 
    14711482        Expression *einit = new DotIdExp(loc, e, idhead); 
    1472       einit = einit->semantic(sc); 
     1483//        einit = einit->semantic(sc); 
    14731484        Argument *arg = (Argument *)arguments->data[0]; 
    14741485        VarDeclaration *ve = new VarDeclaration(loc, arg->type, arg->ident, new ExpInitializer(loc, einit)); 
     
    24562467    {   hasNoDefault = 1; 
    24572468 
    2458     if (global.params.warnings) 
    2459     {   fprintf(stdmsg, "warning - "); 
    2460         error("switch statement has no default"); 
    2461     } 
     2469    warning("switch statement has no default"); 
    24622470 
    24632471    // Generate runtime error if the default is hit 
  • trunk/src/statement.h

    r180 r183  
    2020#include "arraytypes.h" 
    2121#include "dsymbol.h" 
     22#include "lexer.h" 
    2223 
    2324struct OutBuffer; 
     
    8889 
    8990    void error(const char *format, ...); 
     91    void warning(const char *format, ...); 
    9092    virtual void toCBuffer(OutBuffer *buf, HdrGenState *hgs); 
    9193    virtual TryCatchStatement *isTryCatchStatement() { return NULL; } 
  • trunk/src/struct.c

    r182 r183  
    2020#include "id.h" 
    2121#include "statement.h" 
     22#include "template.h" 
    2223 
    2324/********************************* AggregateDeclaration ****************************/ 
     
    4546    sinit = NULL; 
    4647    scope = NULL; 
     48    isnested = 0; 
     49    vthis = NULL; 
     50 
    4751#if V2 
    48     dtor = NULL; 
    49  
    5052    ctor = NULL; 
    5153    defaultCtor = NULL; 
    5254#endif 
     55    dtor = NULL; 
    5356} 
    5457 
     
    164167    // Check for forward referenced types which will fail the size() call 
    165168    Type *t = v->type->toBasetype(); 
     169    if (v->storage_class & STCref) 
     170    {   // References are the size of a pointer 
     171    t = Type::tvoidptr; 
     172    } 
    166173    if (t->ty == Tstruct /*&& isStructDeclaration()*/) 
    167174    {   TypeStruct *ts = (TypeStruct *)t; 
     
    185192    } 
    186193 
    187     memsize = v->type->size(loc); 
    188     memalignsize = v->type->alignsize(); 
    189     xalign = v->type->memalign(sc->structalign); 
     194    memsize = t->size(loc); 
     195    memalignsize = t->alignsize(); 
     196    xalign = t->memalign(sc->structalign); 
    190197    alignmember(xalign, memalignsize, &sc->offset); 
    191198    v->offset = sc->offset; 
     
    202209    //printf(" addField '%s' to '%s' at offset %d, size = %d\n", v->toChars(), toChars(), v->offset, memsize); 
    203210    fields.push(v); 
     211} 
     212 
     213 
     214/**************************************** 
     215 * Returns !=0 if there's an extra member which is the 'this' 
     216 * pointer to the enclosing context (enclosing aggregate or function) 
     217 */ 
     218 
     219int AggregateDeclaration::isNested() 
     220{ 
     221    return isnested; 
    204222} 
    205223 
     
    282300    if (sizeok == 0)        // if not already done the addMember step 
    283301    { 
     302    int hasfunctions = 0; 
    284303    for (i = 0; i < members->dim; i++) 
    285304    { 
     
    287306        //printf("adding member '%s' to '%s'\n", s->toChars(), this->toChars()); 
    288307        s->addMember(sc, this, 1); 
    289     } 
     308        if (s->isFuncDeclaration()) 
     309        hasfunctions = 1; 
     310    } 
     311 
     312    // If nested struct, add in hidden 'this' pointer to outer scope 
     313    if (hasfunctions && !(storage_class & STCstatic)) 
     314        {   Dsymbol *s = toParent2(); 
     315            if (s) 
     316            { 
     317                AggregateDeclaration *ad = s->isAggregateDeclaration(); 
     318                FuncDeclaration *fd = s->isFuncDeclaration(); 
     319 
     320        TemplateInstance *ti; 
     321                if (ad && (ti = ad->parent->isTemplateInstance()) != NULL && ti->isnested || fd) 
     322                {   isnested = 1; 
     323                    Type *t; 
     324                    if (ad) 
     325                        t = ad->handle; 
     326                    else if (fd) 
     327                    {   AggregateDeclaration *ad = fd->isMember2(); 
     328                        if (ad) 
     329                            t = ad->handle; 
     330                        else 
     331                t = Type::tvoidptr; 
     332                    } 
     333                    else 
     334                        assert(0); 
     335            if (t->ty == Tstruct) 
     336            t = Type::tvoidptr; // t should not be a ref type 
     337                    assert(!vthis); 
     338                    vthis = new ThisDeclaration(t); 
     339            //vthis->storage_class |= STCref; 
     340                    members->push(vthis); 
     341                } 
     342            } 
     343        } 
    290344    } 
    291345 
     
    312366    } 
    313367#endif 
     368    Type *t; 
     369    if (s->isDeclaration() && 
     370        (t = s->isDeclaration()->type) != NULL && 
     371        t->toBasetype()->ty == Tstruct) 
     372    {   StructDeclaration *sd = (StructDeclaration *)t->toDsymbol(sc); 
     373        if (sd->isnested) 
     374        error("inner struct %s cannot be a field", sd->toChars()); 
     375    } 
    314376    } 
    315377 
  • trunk/src/template.c

    r181 r183  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2008 by Digital Mars 
     3// Copyright (c) 1999-2009 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
     
    1515 
    1616#include "root.h" 
    17 #include "mem.h" 
     17#include "rmem.h" 
    1818#include "stringtable.h" 
    1919 
     
    187187        goto Lnomatch; 
    188188    } 
     189#if V2 
    189190    VarDeclaration *v1 = s1->isVarDeclaration(); 
    190191    VarDeclaration *v2 = s2->isVarDeclaration(); 
     
    195196        goto Lnomatch; 
    196197    } 
     198#endif 
    197199    } 
    198200    else if (v1) 
     
    262264} 
    263265 
     266#if V2 
    264267Object *objectSyntaxCopy(Object *o) 
    265268{ 
     
    274277    return o; 
    275278} 
     279#endif 
    276280 
    277281 
     
    301305    this->parameters = parameters; 
    302306    this->origParameters = parameters; 
     307#if V2 
    303308    this->constraint = constraint; 
     309#endif 
    304310    this->members = decldefs; 
    305311    this->overnext = NULL; 
     
    326332    } 
    327333    } 
     334#if V2 
    328335    Expression *e = NULL; 
    329336    if (constraint) 
    330337    e = constraint->syntaxCopy(); 
     338#endif 
    331339    d = Dsymbol::arraySyntaxCopy(members); 
    332340    td = new TemplateDeclaration(loc, ident, p, e, d); 
     
    374382    Scope *paramscope = sc->push(paramsym); 
    375383    paramscope->parameterSpecialization = 1; 
     384    paramscope->stc = 0; 
    376385 
    377386    if (global.params.doDocComments) 
     
    534543    paramsym->parent = scope->parent; 
    535544    Scope *paramscope = scope->push(paramsym); 
     545    paramscope->stc = 0; 
    536546 
    537547    // Attempt type deduction 
     
    823833        //printf("t = %p\n", t); 
    824834        dedargs->data[parameters->dim - 1] = (void *)t; 
     835        declareParameter(paramscope, tp, t); 
    825836        goto L2; 
    826837    } 
     
    858869            t->objects.data[i] = (void *)farg->type; 
    859870        } 
     871        declareParameter(paramscope, tp, t); 
    860872        goto L2; 
    861873        } 
     
    18861898        Expression *e2 = isExpression(o2); 
    18871899 
     1900        Dsymbol *s1 = isDsymbol(o1); 
     1901        Dsymbol *s2 = isDsymbol(o2); 
     1902 
     1903        Tuple *v1 = isTuple(o1); 
     1904        Tuple *v2 = isTuple(o2); 
    18881905#if 0 
    18891906        if (t1) printf("t1 = %s\n", t1->toChars()); 
     
    18911908        if (e1) printf("e1 = %s\n", e1->toChars()); 
    18921909        if (e2) printf("e2 = %s\n", e2->toChars()); 
     1910        if (s1) printf("s1 = %s\n", s1->toChars()); 
     1911        if (s2) printf("s2 = %s\n", s2->toChars()); 
     1912        if (v1) printf("v1 = %s\n", v1->toChars()); 
     1913        if (v2) printf("v2 = %s\n", v2->toChars()); 
    18931914#endif 
    18941915 
     
    19371958        } 
    19381959        } 
    1939         // BUG: Need to handle alias and tuple parameters 
     1960        else if (s1 && t2 && t2->ty == Tident) 
     1961        { 
     1962        j = templateParameterLookup(t2, parameters); 
     1963        if (j == -1) 
     1964            goto Lnomatch; 
     1965        TemplateParameter *tp = (TemplateParameter *)parameters->data[j]; 
     1966        // BUG: use tp->matchArg() instead of the following 
     1967        TemplateAliasParameter *ta = tp->isTemplateAliasParameter(); 
     1968        if (!ta) 
     1969            goto Lnomatch; 
     1970        Dsymbol *s = (Dsymbol *)dedtypes->data[j]; 
     1971        if (s) 
     1972        { 
     1973            if (!s1->equals(s)) 
     1974            goto Lnomatch; 
     1975        } 
     1976        else 
     1977        { 
     1978            dedtypes->data[j] = s1; 
     1979        } 
     1980        } 
     1981        else if (s1 && s2) 
     1982        { 
     1983        if (!s1->equals(s2)) 
     1984            goto Lnomatch; 
     1985        } 
     1986        // BUG: Need to handle tuple parameters 
    19401987        else 
    19411988        goto Lnomatch; 
     
    25712618Lnomatch: 
    25722619    *psparam = NULL; 
     2620    //printf("\tm = %d\n", MATCHnomatch); 
    25732621    return MATCHnomatch; 
    25742622} 
     
    31733221    } 
    31743222 
    3175     isNested(tiargs); 
     3223    hasNestedArgs(tiargs); 
    31763224 
    31773225    /* See if there is an existing TemplateInstantiation that already 
     
    32563304         * see bugzilla 2500. 
    32573305         */ 
    3258         && !scx->module->imports(scx->module
     3306        && !scx->module->selfImports(
    32593307#endif 
    32603308       ) 
     
    33003348    argsym->parent = scope->parent; 
    33013349    scope = scope->push(argsym); 
     3350//    scope->stc = 0; 
    33023351 
    33033352    // Declare each template parameter as an alias for the argument type 
    3304     declareParameters(scope); 
     3353    Scope *paramscope = scope->push(); 
     3354    paramscope->stc = 0; 
     3355    declareParameters(paramscope); 
     3356    paramscope->pop(); 
    33053357 
    33063358    // Add members of template instance to template instance symbol table 
     
    37723824 */ 
    37733825 
    3774 int TemplateInstance::isNested(Objects *args) 
     3826int TemplateInstance::hasNestedArgs(Objects *args) 
    37753827{   int nested = 0; 
    3776     //printf("TemplateInstance::isNested('%s')\n", tempdecl->ident->toChars()); 
     3828    //printf("TemplateInstance::hasNestedArgs('%s')\n", tempdecl->ident->toChars()); 
    37773829 
    37783830    /* A nested instance happens when an argument references a local 
     
    38433895    else if (va) 
    38443896    { 
    3845         nested |= isNested(&va->objects); 
     3897        nested |= hasNestedArgs(&va->objects); 
    38463898    } 
    38473899    } 
  • trunk/src/template.h

    r174 r183  
    5252 
    5353    TemplateParameters *origParameters; // originals for Ddoc 
    54  
     54#if V2 
    5555    Expression *constraint; 
    56  
     56#endif 
    5757    Array instances;            // array of TemplateInstance's 
    5858 
     
    6464 
    6565    TemplateDeclaration(Loc loc, Identifier *id, TemplateParameters *parameters, 
    66     Expression *constraint, Array *decldefs); 
     66#if V2 
     67    Expression *constraint, 
     68#endif 
     69    Array *decldefs); 
    6770    Dsymbol *syntaxCopy(Dsymbol *); 
    6871    void semantic(Scope *sc); 
     
    112115    virtual TemplateValueParameter *isTemplateValueParameter(); 
    113116    virtual TemplateAliasParameter *isTemplateAliasParameter(); 
     117#if V2 
    114118    virtual TemplateThisParameter *isTemplateThisParameter(); 
     119#endif 
    115120    virtual TemplateTupleParameter *isTemplateTupleParameter(); 
    116121 
     
    309314    TemplateDeclaration *findBestMatch(Scope *sc); 
    310315    void declareParameters(Scope *sc); 
    311     int isNested(Objects *tiargs); 
     316    int hasNestedArgs(Objects *tiargs); 
    312317    Identifier *genIdent(); 
    313318 
  • trunk/src/tocsym.c

    r182 r183  
    2727#include "id.h" 
    2828 
    29 #include <mem.h> 
     29#include "rmem.h" 
    3030 
    3131// Back end 
  • trunk/src/todt.c

    r182 r183  
    893893    { 
    894894    VarDeclaration *v = (VarDeclaration *)fields.data[i]; 
    895     Initializer *init; 
    896  
    897895    //printf("\tfield '%s' voffset %d, offset = %d\n", v->toChars(), v->offset, offset); 
    898896    dt = NULL; 
    899     init = v->init; 
    900     if (init) 
    901     {   //printf("\t\thas initializer %s\n", init->toChars()); 
    902         ExpInitializer *ei = init->isExpInitializer(); 
    903         Type *tb = v->type->toBasetype(); 
    904         if (ei && tb->ty == Tsarray) 
    905         ((TypeSArray *)tb)->toDtElem(&dt, ei->exp); 
    906         else 
    907         dt = init->toDt(); 
    908     } 
    909     else if (v->offset >= offset) 
    910         v->type->toDt(&dt); 
     897    int sz; 
     898 
     899    if (v->storage_class & STCref) 
     900    { 
     901        sz = PTRSIZE; 
     902        if (v->offset >= offset) 
     903        dtnzeros(&dt, sz); 
     904    } 
     905    else 
     906    { 
     907        sz = v->type->size(); 
     908        Initializer *init = v->init; 
     909        if (init) 
     910        {   //printf("\t\thas initializer %s\n", init->toChars()); 
     911        ExpInitializer *ei = init->isExpInitializer(); 
     912        Type *tb = v->type->toBasetype(); 
     913        if (ei && tb->ty == Tsarray) 
     914            ((TypeSArray *)tb)->toDtElem(&dt, ei->exp); 
     915        else 
     916            dt = init->toDt(); 
     917        } 
     918        else if (v->offset >= offset) 
     919        v->type->toDt(&dt); 
     920    } 
    911921    if (dt) 
    912922    { 
     
    918928            dtnzeros(pdt, v->offset - offset); 
    919929        dtcat(pdt, dt); 
    920         offset = v->offset + v->type->size()
     930        offset = v->offset + sz
    921931        } 
    922932    } 
  • trunk/src/toir.c

    r182 r183  
    3232#if _WIN32 
    3333#include    "..\tk\mem.h"   // for mem_malloc 
    34 #elif linux || __APPLE__ 
     34#else 
    3535#include    "../tk/mem.h"   // for mem_malloc 
    3636#endif 
     
    188188        } 
    189189        else 
    190         {   /* Enclosed by a class. That means the current 
    191              * function must be a member function of that class
     190        {   /* Enclosed by an aggregate. That means the current 
     191             * function must be a member function of that aggregate
    192192             */ 
    193             ClassDeclaration *cd = s->isClassDeclaration(); 
    194             if (!cd) 
     193            ClassDeclaration *cd; 
     194            StructDeclaration *sd; 
     195            AggregateDeclaration *ad = s->isAggregateDeclaration(); 
     196            if (!ad) 
    195197            goto Lnoframe; 
    196             if (//cd->baseClass == fd || 
    197            fd->isClassDeclaration() && 
     198            cd = s->isClassDeclaration(); 
     199            if (cd && fd->isClassDeclaration() && 
    198200            fd->isClassDeclaration()->isBaseOf(cd, NULL)) 
    199201            break; 
    200             if (!cd->isNested() || !cd->vthis) 
     202            sd = s->isStructDeclaration(); 
     203            if (fd == sd) 
     204            break; 
     205            if (!ad->isNested() || !ad->vthis) 
    201206            { 
    202207              Lnoframe: 
     
    204209            return el_long(TYnptr, 0);  // error recovery 
    205210            } 
    206             ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYint, cd->vthis->offset)); 
     211            ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYint, ad->vthis->offset)); 
    207212            ethis = el_una(OPind, TYnptr, ethis); 
    208213            if (fdparent == s->toParent2()) 
     
    250255 
    251256 
     257/************************* 
     258 * Initialize the hidden aggregate member, vthis, with 
     259 * the context pointer. 
     260 * Returns: 
     261 *  *(ey + ad.vthis.offset) = this; 
     262 */ 
     263elem *setEthis(Loc loc, IRState *irs, elem *ey, AggregateDeclaration *ad) 
     264{ 
     265    elem *ethis; 
     266    FuncDeclaration *thisfd = irs->getFunc(); 
     267    int offset = 0; 
     268    Dsymbol *cdp = ad->toParent2(); // class/func we're nested in 
     269 
     270    //printf("setEthis(ad = %s, cdp = %s, thisfd = %s)\n", ad->toChars(), cdp->toChars(), thisfd->toChars()); 
     271 
     272    if (cdp == thisfd) 
     273    {   /* Class we're new'ing is a local class in this function: 
     274     *  void thisfd() { class ad { } } 
     275     */ 
     276    if (irs->sclosure) 
     277        ethis = el_var(irs->sclosure); 
     278    else if (irs->sthis) 
     279    { 
     280#if V2 
     281        if (thisfd->closureVars.dim) 
     282#else 
     283        if (thisfd->nestedFrameRef) 
     284#endif 
     285        { 
     286        ethis = el_ptr(irs->sthis); 
     287        } 
     288        else 
     289        ethis = el_var(irs->sthis); 
     290    } 
     291    else 
     292    { 
     293        ethis = el_long(TYnptr, 0); 
     294#if V2 
     295        if (thisfd->closureVars.dim) 
     296#else 
     297        if (thisfd->nestedFrameRef) 
     298#endif 
     299        { 
     300        ethis->Eoper = OPframeptr; 
     301        } 
     302    } 
     303    } 
     304    else if (thisfd->vthis && 
     305      (cdp == thisfd->toParent2() || 
     306       (cdp->isClassDeclaration() && 
     307        cdp->isClassDeclaration()->isBaseOf(thisfd->toParent2()->isClassDeclaration(), &offset) 
     308       ) 
     309      ) 
     310    ) 
     311    {   /* Class we're new'ing is at the same level as thisfd 
     312     */ 
     313    assert(offset == 0);    // BUG: should handle this case 
     314    ethis = el_var(irs->sthis); 
     315    } 
     316    else 
     317    { 
     318    ethis = getEthis(loc, irs, ad->toParent2()); 
     319    ethis = el_una(OPaddr, TYnptr, ethis); 
     320    } 
     321 
     322    ey = el_bin(OPadd, TYnptr, ey, el_long(TYint, ad->vthis->offset)); 
     323    ey = el_una(OPind, TYnptr, ey); 
     324    ey = el_bin(OPeq, TYnptr, ey, ethis); 
     325    return ey; 
     326} 
     327 
    252328/******************************************* 
    253329 * Convert intrinsic function to operator. 
     
    257333int intrinsic_op(char *name) 
    258334{ 
     335    //printf("intrinsic_op(%s)\n", name); 
    259336    static const char *namearray[] = 
    260337    { 
     338#if V1 
    261339    "4math3cosFeZe", 
    262340    "4math3sinFeZe", 
     
    269347    "4math6rndtolFeZl", 
    270348 
    271 #if V1 
    272349    "9intrinsic2btFPkkZi", 
    273 #else 
    274     "9intrinsic2btFxPkkZi", 
    275 #endif 
    276350    "9intrinsic3bsfFkZi", 
    277351    "9intrinsic3bsrFkZi", 
     
    286360    "9intrinsic5outplFkkZk", 
    287361    "9intrinsic5outpwFktZt", 
     362#elif V2 
     363    /* The names are mangled differently because of the pure and 
     364     * nothrow attributes. 
     365     */ 
     366    "4math3cosFNaNbeZe", 
     367    "4math3sinFNaNbeZe", 
     368    "4math4fabsFNaNbeZe", 
     369    "4math4rintFNaNbeZe", 
     370    "4math4sqrtFNaNbdZd", 
     371    "4math4sqrtFNaNbeZe", 
     372    "4math4sqrtFNaNbfZf", 
     373    "4math5ldexpFNaNbeiZe", 
     374    "4math6rndtolFNaNbeZl", 
     375 
     376    "9intrinsic2btFNaNbxPkkZi", 
     377    "9intrinsic3bsfFNaNbkZi", 
     378    "9intrinsic3bsrFNaNbkZi", 
     379    "9intrinsic3btcFNbPkkZi", 
     380    "9intrinsic3btrFNbPkkZi", 
     381    "9intrinsic3btsFNbPkkZi", 
     382    "9intrinsic3inpFNbkZh", 
     383    "9intrinsic4inplFNbkZk", 
     384    "9intrinsic4inpwFNbkZt", 
     385    "9intrinsic4outpFNbkhZh", 
     386    "9intrinsic5bswapFNaNbkZk", 
     387    "9intrinsic5outplFNbkkZk", 
     388    "9intrinsic5outpwFNbktZt", 
     389#endif 
    288390    }; 
    289391    static unsigned char ioptab[] = 
     
    330432 
    331433    length = strlen(name); 
    332     if (length < 11 || memcmp(name, "_D3std", 6) != 0) 
     434    if (length < 11 || 
     435    !(name[7] == 'm' || name[7] == 'i') || 
     436    memcmp(name, "_D3std", 6) != 0) 
    333437    return -1; 
    334438 
  • trunk/src/toir.h

    r125 r183  
    11 
    2 // Copyright (c) 1999-2006 by Digital Mars 
     2// Copyright (c) 1999-2009 by Digital Mars 
    33// All Rights Reserved 
    44// written by Walter Bright 
     
    1616elem *incUsageElem(IRState *irs, Loc loc); 
    1717elem *getEthis(Loc loc, IRState *irs, Dsymbol *fd); 
     18elem *setEthis(Loc loc, IRState *irs, elem *ey, AggregateDeclaration *ad); 
    1819int intrinsic_op(char *name); 
    1920elem *resolveLengthVar(VarDeclaration *lengthVar, elem **pe, Type *t1); 
  • trunk/src/toobj.c

    r182 r183  
    2626#include "template.h" 
    2727 
    28 #include <mem.h> 
     28#include "rmem.h" 
    2929#include "cc.h" 
    3030#include "global.h" 
     
    157157    if (m->needModuleInfo()) 
    158158    {   Symbol *s = m->toSymbol(); 
     159 
     160        /* Weak references don't pull objects in from the library, 
     161         * they resolve to 0 if not pulled in by something else. 
     162         * Don't pull in a module just because it was imported. 
     163         */ 
     164#if !OMFOBJ // Optlink crashes with weak symbols at EIP 41AFE7, 402000 
    159165        s->Sflags |= SFLweak; 
     166#endif 
    160167        dtxoff(&dt, s, 0, TYnptr); 
    161168    } 
     
    643650            { 
    644651            if (global.params.warnings) 
    645             {   fprintf(stdmsg, "warning - "); 
     652            { 
    646653                TypeFunction *tf = (TypeFunction *)fd->type; 
    647654                if (tf->ty == Tfunction) 
    648                 error("%s%s is hidden by %s\n", fd->toPrettyChars(), Argument::argsTypesToChars(tf->parameters, tf->varargs), toChars()); 
     655                warning("%s%s is hidden by %s\n", fd->toPrettyChars(), Argument::argsTypesToChars(tf->parameters, tf->varargs), toChars()); 
    649656                else 
    650                 error("%s is hidden by %s\n", fd->toPrettyChars(), toChars()); 
     657                warning("%s is hidden by %s\n", fd->toPrettyChars(), toChars()); 
    651658            } 
    652659            s = rtlsym[RTLSYM_DHIDDENFUNC]; 
     
    927934        sinit->Sclass = SCcomdat; 
    928935#else 
    929         if (parent && parent->isTemplateInstance()) 
     936        if (inTemplateInstance()) 
     937        { 
    930938        sinit->Sclass = SCcomdat; 
     939        } 
    931940        else 
     941        { 
    932942        sinit->Sclass = SCglobal; 
     943        } 
    933944#endif 
    934945        sinit->Sfl = FLdata; 
  • trunk/src/traits.c

    r171 r183  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2007 by Digital Mars 
     3// Copyright (c) 1999-2009 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
     
    1313#include <ctype.h> 
    1414#include <assert.h> 
     15#if _MSC_VER 
     16#include <complex> 
     17#else 
    1518#include <complex.h> 
     19#endif 
    1620#include <math.h> 
    1721 
     
    2529#endif 
    2630 
    27 #if IN_GCC 
    28 #include "mem.h" 
    29 #elif _WIN32 
    30 #include "..\root\mem.h" 
    31 #elif linux 
    32 #include "../root/mem.h" 
    33 #endif 
     31#include "rmem.h" 
    3432 
    3533//#include "port.h" 
     
    5452#define LOGSEMANTIC 0 
    5553 
     54#if V2 
     55 
    5656/************************************************ 
    5757 * Delegate to be passed to overloadApply() that looks 
     
    439439 
    440440 
     441#endif 
  • trunk/src/typinf.c

    r182 r183  
    2828#include "aggregate.h" 
    2929 
    30 #include <mem.h> 
     30#include "rmem.h" 
    3131#include "cc.h" 
    3232#include "global.h"