Wiki Roadmap Timeline Tickets New Ticket Source Search Help / Guide About Trac Login

Changeset 658:50383e476c7e

Show
Ignore:
Timestamp:
10/06/08 10:22:11 (2 months ago)
Author:
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
branch:
default
Message:

Upgraded frontend to DMD 1.035

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • dmd/attrib.c

    r571 r658  
    3535#include "../gen/logger.h" 
    3636 
    37 extern void obj_includelib(char *name); 
     37extern void obj_includelib(const char *name); 
    3838void obj_startaddress(Symbol *s); 
    3939 

  • dmd/class.c

    r336 r658  
    478478        error("static class cannot inherit from nested class %s", baseClass->toChars()); 
    479479        if (toParent2() != baseClass->toParent2()) 
    480         error("super class %s is nested within %s, not %s", 
     480        { 
     481        if (toParent2()) 
     482        { 
     483            error("is nested within %s, but super class %s is nested within %s", 
     484            toParent2()->toChars(), 
    481485            baseClass->toChars(), 
    482             baseClass->toParent2()->toChars(), 
    483             toParent2()->toChars()); 
     486            baseClass->toParent2()->toChars()); 
     487        } 
     488        else 
     489        { 
     490            error("is not nested, but super class %s is nested within %s", 
     491            baseClass->toChars(), 
     492            baseClass->toParent2()->toChars()); 
     493        } 
     494        isnested = 0; 
     495        } 
    484496    } 
    485497    else if (!(storage_class & STCstatic)) 
    …… 
    580592     */ 
    581593    ctor = (CtorDeclaration *)search(0, Id::ctor, 0); 
    582     if (ctor && ctor->toParent() != this) 
     594    if (ctor && (ctor->toParent() != this || !ctor->isCtorDeclaration())) 
    583595    ctor = NULL; 
    584596 

  • dmd/constfold.c

    r637 r658  
    707707    StringExp *es2 = (StringExp *)e2; 
    708708 
    709     assert(es1->sz == es2->sz); 
     709    if (es1->sz != es2->sz) 
     710    { 
     711        assert(global.errors); 
     712        return EXP_CANT_INTERPRET; 
     713    } 
    710714    if (es1->len == es2->len && 
    711715        memcmp(es1->string, es2->string, es1->sz * es1->len) == 0) 
    …… 
    13451349    int sz = es1->sz; 
    13461350 
    1347     assert(sz == es2->sz); 
     1351    if (sz != es2->sz) 
     1352    { 
     1353        /* Can happen with: 
     1354         *   auto s = "foo"d ~ "bar"c; 
     1355         */ 
     1356        assert(global.errors); 
     1357        return e; 
     1358    } 
    13481359    s = mem.malloc((len + 1) * sz); 
    13491360    memcpy(s, es1->string, es1->len * sz); 

  • dmd/declaration.c

    r468 r658  
    899899    if (init) 
    900900    { 
     901    sc = sc->push(); 
     902    sc->stc &= ~(STCconst | STCinvariant | STCpure); 
     903 
    901904    ArrayInitializer *ai = init->isArrayInitializer(); 
    902905    if (ai && tb->ty == Taarray) 
    …… 
    10321035        } 
    10331036    } 
     1037    sc = sc->pop(); 
    10341038    } 
    10351039} 

  • dmd/func.c

    r644 r658  
    141141    Dsymbol *parent = toParent(); 
    142142 
     143    if (ident == Id::ctor && !isCtorDeclaration()) 
     144    error("_ctor is reserved for constructors"); 
     145 
    143146    if (isConst() || isAuto() || isScope()) 
    144147    error("functions cannot be const or auto"); 
    …… 
    25442547    Expression *e = new IdentifierExp(0, id); 
    25452548    e = new AddAssignExp(0, e, new IntegerExp(-1)); 
    2546     e = new EqualExp(TOKnotequal, 0, e, new IntegerExp(1)); 
     2549    e = new EqualExp(TOKnotequal, 0, e, new IntegerExp(0)); 
    25472550    s = new IfStatement(0, NULL, e, new ReturnStatement(0, NULL), NULL); 
    25482551    sa->push(s); 

  • dmd/id.c

    r486 r658  
    165165Identifier *Id::aaValues; 
    166166Identifier *Id::aaRehash; 
     167Identifier *Id::GNU_asm; 
    167168Identifier *Id::lib; 
    168169Identifier *Id::msg; 
    169 Identifier *Id::GNU_asm; 
    170170Identifier *Id::intrinsic; 
    171171Identifier *Id::va_intrinsic; 
    …… 
    347347    aaValues = Lexer::idPool("_aaValues"); 
    348348    aaRehash = Lexer::idPool("_aaRehash"); 
     349    GNU_asm = Lexer::idPool("GNU_asm"); 
    349350    lib = Lexer::idPool("lib"); 
    350351    msg = Lexer::idPool("msg"); 
    351     GNU_asm = Lexer::idPool("GNU_asm"); 
    352352    intrinsic = Lexer::idPool("intrinsic"); 
    353353    va_intrinsic = Lexer::idPool("va_intrinsic"); 

  • dmd/id.h

    r486 r658  
    167167    static Identifier *aaValues; 
    168168    static Identifier *aaRehash; 
     169    static Identifier *GNU_asm; 
    169170    static Identifier *lib; 
    170171    static Identifier *msg; 
    171     static Identifier *GNU_asm; 
    172172    static Identifier *intrinsic; 
    173173    static Identifier *va_intrinsic; 

  • dmd/idgen.c

    r486 r658  
    11 
    22// Compiler implementation of the D programming language 
    3 // Copyright (c) 1999-2006 by Digital Mars 
     3// Copyright (c) 1999-2008 by Digital Mars 
    44// All Rights Reserved 
    55// written by Walter Bright 
    …… 
    2323struct Msgtable 
    2424{ 
    25     char *ident;  // name to use in DMD source 
    26     char *name;   // name in D executable 
     25    const char *ident;    // name to use in DMD source 
     26    const char *name; // name in D executable 
    2727}; 
    2828 
    …… 
    210210 
    211211    // For pragma's 
     212    { "GNU_asm" }, 
    212213    { "lib" }, 
    213214    { "msg" }, 
    214     { "GNU_asm" }, 
    215215 
    216216    // LLVMDC pragma's 
    …… 
    226226    { "llvmdc" }, 
    227227 
    228     // For toHash/toString 
     228    // For special functions 
    229229    { "tohash", "toHash" }, 
    230230    { "tostring", "toString" }, 
    …… 
    261261 
    262262    for (i = 0; i < sizeof(msgtable) / sizeof(msgtable[0]); i++) 
    263     {   char *id = msgtable[i].ident; 
     263    {   const char *id = msgtable[i].ident; 
    264264 
    265265        fprintf(fp,"    static Identifier *%s;\n", id); 
    …… 
    286286 
    287287    for (i = 0; i < sizeof(msgtable) / sizeof(msgtable[0]); i++) 
    288     {   char *id = msgtable[i].ident; 
    289         char *p = msgtable[i].name; 
     288    {   const char *id = msgtable[i].ident; 
     289        const char *p = msgtable[i].name; 
    290290 
    291291        if (!p) 
    …… 
    298298 
    299299    for (i = 0; i < sizeof(msgtable) / sizeof(msgtable[0]); i++) 
    300     {   char *id = msgtable[i].ident; 
    301         char *p = msgtable[i].name; 
     300    {   const char *id = msgtable[i].ident; 
     301        const char *p = msgtable[i].name; 
    302302 
    303303        if (!p) 

  • dmd/interpret.c

    r588 r658  
    7878    } 
    7979 
    80     //printf("test2 %d, %p\n", semanticRun, scope); 
    8180    if (semanticRun == 0 && scope) 
    8281    { 
    8382    semantic3(scope); 
     83    if (global.errors)  // if errors compiling this function 
     84        return NULL; 
    8485    } 
    8586    if (semanticRun < 2) 

  • dmd/lexer.c

    r366 r658  
    8989/************************* Token **********************************************/ 
    9090 
    91 char *Token::tochars[TOKMAX]; 
     91const char *Token::tochars[TOKMAX]; 
    9292 
    9393void *Token::operator new(size_t size) 
    …… 
    111111#endif 
    112112 
    113 char *Token::toChars() 
    114 {   char *p; 
     113const char *Token::toChars() 
     114{   const char *p; 
    115115    static char buffer[3 + 3 * sizeof(value) + 1]; 
    116116 
    …… 
    240240} 
    241241 
    242 char *Token::toChars(enum TOK value) 
    243 {   char *p; 
     242const char *Token::toChars(enum TOK value) 
     243{   const char *p; 
    244244    static char buffer[3 + 3 * sizeof(value) + 1]; 
    245245 
    …… 
    468468    {   dchar_t dc; 
    469469 
    470     char *q = utf_decodeChar((unsigned char *)p, len, &idx, &dc); 
     470    const char *q = utf_decodeChar((unsigned char *)p, len, &idx, &dc); 
    471471    if (q) 
    472472        goto Linvalid; 
    …… 
    719719            unsigned minor = 0; 
    720720 
    721             for (char *p = global.version + 1; 1; p++) 
     721            for (const char *p = global.version + 1; 1; p++) 
    722722            { 
    723723                char c = *p; 
    …… 
    21872187        if (d >= r) 
    21882188        break; 
    2189         if (n && n * r + d <= n) 
     2189        uinteger_t n2 = n * r; 
     2190        //printf("n2 / r = %llx, n = %llx\n", n2/r, n); 
     2191        if (n2 / r != n || n2 + d < n) 
    21902192        { 
    21912193        error ("integer overflow"); 
    …… 
    21932195        } 
    21942196 
    2195         n = n * r + d; 
     2197        n = n2 + d; 
    21962198        p++; 
    21972199    } 
    …… 
    26042606    size_t len; 
    26052607    size_t idx; 
    2606     char *msg; 
     2608    const char *msg; 
    26072609 
    26082610    c = *s; 
    …… 
    28022804 
    28032805struct Keyword 
    2804 {   char *name; 
     2806{   const char *name; 
    28052807    enum TOK value; 
    28062808}; 
    …… 
    29292931    {   "__FILE__", TOKfile     }, 
    29302932    {   "__LINE__", TOKline     }, 
     2933    {   "shared",   TOKshared   }, 
    29312934#endif 
    29322935}; 
    …… 
    29542957 
    29552958    for (u = 0; u < nkeywords; u++) 
    2956     {   char *s; 
     2959    {   const char *s; 
    29572960 
    29582961    //printf("keyword[%d] = '%s'\n",u, keywords[u].name); 

  • dmd/lexer.h

    r599 r658  
    159159    TOKline, 
    160160    TOKfile, 
     161    TOKshared, 
    161162#endif 
    162163 
    …… 
    241242#endif 
    242243 
    243     static char *tochars[TOKMAX]; 
     244    static const char *tochars[TOKMAX]; 
    244245    static void *operator new(size_t sz); 
    245246 
    246247    int isKeyword(); 
    247248    void print(); 
    248     char *toChars(); 
    249     static char *toChars(enum TOK); 
     249    const char *toChars(); 
     250    static const char *toChars(enum TOK); 
    250251}; 
    251252 

  • dmd/mars.c

    r651 r658  
    6666    copyright = "Copyright (c) 1999-2008 by Digital Mars and Tomas Lindquist Olsen"; 
    6767    written = "written by Walter Bright and Tomas Lindquist Olsen"; 
    68     version = "v1.034"; 
     68    version = "v1.035"; 
    6969    llvmdc_version = "0.1"; 
    7070    global.structalign = 8; 

  • dmd/mtype.c

    r642 r658  
    790790TypeBasic::TypeBasic(TY ty) 
    791791    : Type(ty, NULL) 
    792 {   char *c; 
    793     char *d; 
     792{   const char *c; 
     793    const char *d; 
    794794    unsigned flags; 
    795795 
    …… 
    936936char *TypeBasic::toChars() 
    937937{ 
    938     return dstring; 
     938    return (char *)dstring; 
    939939} 
    940940 

  • dmd/mtype.h

    r508 r658  
    267267struct TypeBasic : Type 
    268268{ 
    269     char *dstring; 
    270     char *cstring; 
     269    const char *dstring; 
     270    const char *cstring; 
    271271    unsigned flags; 
    272272 

  • dmd/parse.c

    r336 r658  
    23752375    Token *t; 
    23762376    int braces; 
     2377    int brackets; 
    23772378 
    23782379    switch (token.value) 
    …… 
    24622463 
    24632464    case TOKlbracket: 
     2465        /* Scan ahead to see if it is an array initializer or 
     2466         * an expression. 
     2467         * If it ends with a ';', it is an array initializer. 
     2468         */ 
     2469        brackets = 1; 
     2470        for (t = peek(&token); 1; t = peek(t)) 
     2471        { 
     2472        switch (t->value) 
     2473        { 
     2474            case TOKlbracket: 
     2475            brackets++; 
     2476            continue; 
     2477 
     2478            case TOKrbracket: 
     2479            if (--brackets == 0) 
     2480            {   t = peek(t); 
     2481                if (t->value != TOKsemicolon && 
     2482                t->value != TOKcomma && 
     2483                t->value != TOKrcurly) 
     2484                goto Lexpression; 
     2485                break; 
     2486            } 
     2487            continue; 
     2488 
     2489            case TOKeof: 
     2490            break; 
     2491 
     2492            default: 
     2493            continue; 
     2494        } 
     2495        break; 
     2496        } 
     2497 
    24642498        ia = new ArrayInitializer(loc); 
    24652499        nextToken(); 
    …… 
    42484282        if (token.value != TOKrbracket) 
    42494283        { 
    4250         while (1) 
     4284        while (token.value != TOKeof) 
    42514285        { 
    42524286            Expression *e = parseAssignExp(); 
    …… 
    45264560        switch (tk->value) 
    45274561        { 
     4562            case TOKnot: 
     4563            tk = peek(tk); 
     4564            if (tk->value == TOKis) // !is 
     4565                break; 
    45284566            case TOKdot: 
    45294567            case TOKplusplus: 
    45304568            case TOKminusminus: 
    4531             case TOKnot: 
    45324569            case TOKdelete: 
    45334570            case TOKnew: 
    …… 
    51505187{ 
    51515188    s->addComment(combineComments(blockComment, token.lineComment)); 
     5189    token.lineComment = NULL; 
    51525190} 
    51535191 

  • dmd/root.c

    r571 r658  
    189189char *Object::toChars() 
    190190{ 
    191     return "Object"; 
     191    return (char *)"Object"; 
    192192} 
    193193 
    …… 
    313313} 
    314314 
    315 char *FileName::combine(char *path, char *name) 
     315char *FileName::combine(const char *path, const char *name) 
    316316{   char *f; 
    317317    size_t pathlen; 
    …… 
    319319 
    320320    if (!path || !*path) 
    321     return name; 
     321    return (char *)name; 
    322322    pathlen = strlen(path); 
    323323    namelen = strlen(name); 
    …… 
    745745 */ 
    746746 
    747 char *FileName::searchPath(Array *path, char *name, int cwd) 
     747char *FileName::searchPath(Array *path, const char *name, int cwd) 
    748748{ 
    749749    if (absolute(name)) 
    750750    { 
    751     return exists(name) ? name : NULL; 
     751    return exists(name) ? (char *)name : NULL; 
    752752    } 
    753753    if (cwd) 
    754754    { 
    755755    if (exists(name)) 
    756         return name; 
     756        return (char *)name; 
    757757    } 
    758758    if (path) 
    …… 
    14391439} 
    14401440 
    1441 void OutBuffer::prependstring(char *string) 
     1441void OutBuffer::prependstring(const char *string) 
    14421442{   unsigned len; 
    14431443 
    …… 
    16991699 */ 
    17001700 
    1701 unsigned OutBuffer::bracket(unsigned i, char *left, unsigned j, char *right) 
     1701unsigned OutBuffer::bracket(unsigned i, const char *left, unsigned j, const char *right) 
    17021702{ 
    17031703    size_t leftlen = strlen(left); 

  • dmd/root.h

    r336 r658  
    132132    static char *replaceName(char *path, char *name); 
    133133 
    134     static char *combine(char *path, char *name); 
     134    static char *combine(const char *path, const char *name); 
    135135    static Array *splitPath(const char *path); 
    136136    static FileName *defaultExt(const char *name, const char *ext); 
    …… 
    139139 
    140140    void CopyTo(FileName *to); 
    141     static char *searchPath(Array *path, char *name, int cwd); 
     141    static char *searchPath(Array *path, const char *name, int cwd); 
    142142    static int exists(const char *name); 
    143143    static void ensurePathExists(const char *path); 
    …… 
    268268    void writedstring(const char *string); 
    269269    void writedstring(const wchar_t *string); 
    270     void prependstring(char *string); 
     270    void prependstring(const char *string); 
    271271    void writenl();         // write newline 
    272272    void writeByte(unsigned b); 
    …… 
    289289#endif 
    290290    void bracket(char left, char right); 
    291     unsigned bracket(unsigned i, char *left, unsigned j, char *right); 
     291    unsigned bracket(unsigned i, const char *left, unsigned j, const char *right); 
    292292    void spread(unsigned offset, unsigned nbytes); 
    293293    unsigned insert(unsigned offset, const void *data, unsigned nbytes); 
Copyright © 2008, LDC Development Team.