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

Changeset 703:06576ece1a1b

Show
Ignore:
Timestamp:
10/13/08 17:19:32 (3 months ago)
Author:
Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
branch:
default
Message:

Changed premake.lua to work with mingw.
Implemented array operations, not perfect but ok for tonight. closes #89

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • dmd/arrayop.c

    r664 r703  
    2929#include "init.h" 
    3030 
    31 // FIXME 
    32 int binary(const char *p , const char **tab, int high) 
    33 { 
    34     assert(0); 
    35 } 
    36  
    37 /************************************** 
    38  * Hash table of array op functions already generated or known about. 
    39  */ 
    40  
    41 StringTable arrayfuncs; 
    4231 
    4332/*********************************** 
     
    4736Expression *BinExp::arrayOp(Scope *sc) 
    4837{ 
    49     // FIXME 
    50     error("array operations not yet implemented"); 
    51     fatal(); 
    52  
    5338    Expressions *arguments = new Expressions(); 
    5439 
     
    7661    /* Look up name in hash table 
    7762     */ 
    78     StringValue *sv = arrayfuncs.update(name, namelen); 
     63    StringValue *sv = sc->module->arrayfuncs.update(name, namelen); 
    7964    FuncDeclaration *fd = (FuncDeclaration *)sv->ptrvalue; 
    8065    if (!fd) 
    8166    { 
    82     /* Some of the array op functions are written as library functions, 
    83      * presumably to optimize them with special CPU vector instructions. 
    84      * List those library functions here, in alpha order. 
    85      */ 
    86     static const char *libArrayopFuncs[] = 
    87     { 
    88         "_arrayExpSliceAddass_a", 
    89         "_arrayExpSliceAddass_d",       // T[]+=T 
    90         "_arrayExpSliceAddass_f",       // T[]+=T 
    91         "_arrayExpSliceAddass_g", 
    92         "_arrayExpSliceAddass_h", 
    93         "_arrayExpSliceAddass_i", 
    94         "_arrayExpSliceAddass_k", 
    95         "_arrayExpSliceAddass_s", 
    96         "_arrayExpSliceAddass_t", 
    97         "_arrayExpSliceAddass_u", 
    98         "_arrayExpSliceAddass_w", 
    99  
    100         "_arrayExpSliceDivass_d",       // T[]/=T 
    101         "_arrayExpSliceDivass_f",       // T[]/=T 
    102  
    103         "_arrayExpSliceMinSliceAssign_a", 
    104         "_arrayExpSliceMinSliceAssign_d",   // T[]=T-T[] 
    105         "_arrayExpSliceMinSliceAssign_f",   // T[]=T-T[] 
    106         "_arrayExpSliceMinSliceAssign_g", 
    107         "_arrayExpSliceMinSliceAssign_h", 
    108         "_arrayExpSliceMinSliceAssign_i", 
    109         "_arrayExpSliceMinSliceAssign_k", 
    110         "_arrayExpSliceMinSliceAssign_s", 
    111         "_arrayExpSliceMinSliceAssign_t", 
    112         "_arrayExpSliceMinSliceAssign_u", 
    113         "_arrayExpSliceMinSliceAssign_w", 
    114  
    115         "_arrayExpSliceMinass_a", 
    116         "_arrayExpSliceMinass_d",       // T[]-=T 
    117         "_arrayExpSliceMinass_f",       // T[]-=T 
    118         "_arrayExpSliceMinass_g", 
    119         "_arrayExpSliceMinass_h", 
    120         "_arrayExpSliceMinass_i", 
    121         "_arrayExpSliceMinass_k", 
    122         "_arrayExpSliceMinass_s", 
    123         "_arrayExpSliceMinass_t", 
    124         "_arrayExpSliceMinass_u", 
    125         "_arrayExpSliceMinass_w", 
    126  
    127         "_arrayExpSliceMulass_d",       // T[]*=T 
    128         "_arrayExpSliceMulass_f",       // T[]*=T 
    129         "_arrayExpSliceMulass_i", 
    130         "_arrayExpSliceMulass_k", 
    131         "_arrayExpSliceMulass_s", 
    132         "_arrayExpSliceMulass_t", 
    133         "_arrayExpSliceMulass_u", 
    134         "_arrayExpSliceMulass_w", 
    135  
    136         "_arraySliceExpAddSliceAssign_a", 
    137         "_arraySliceExpAddSliceAssign_d",   // T[]=T[]+T 
    138         "_arraySliceExpAddSliceAssign_f",   // T[]=T[]+T 
    139         "_arraySliceExpAddSliceAssign_g", 
    140         "_arraySliceExpAddSliceAssign_h", 
    141         "_arraySliceExpAddSliceAssign_i", 
    142         "_arraySliceExpAddSliceAssign_k", 
    143         "_arraySliceExpAddSliceAssign_s", 
    144         "_arraySliceExpAddSliceAssign_t", 
    145         "_arraySliceExpAddSliceAssign_u", 
    146         "_arraySliceExpAddSliceAssign_w", 
    147  
    148         "_arraySliceExpDivSliceAssign_d",   // T[]=T[]/T 
    149         "_arraySliceExpDivSliceAssign_f",   // T[]=T[]/T 
    150  
    151         "_arraySliceExpMinSliceAssign_a", 
    152         "_arraySliceExpMinSliceAssign_d",   // T[]=T[]-T 
    153         "_arraySliceExpMinSliceAssign_f",   // T[]=T[]-T 
    154         "_arraySliceExpMinSliceAssign_g", 
    155         "_arraySliceExpMinSliceAssign_h", 
    156         "_arraySliceExpMinSliceAssign_i", 
    157         "_arraySliceExpMinSliceAssign_k", 
    158         "_arraySliceExpMinSliceAssign_s", 
    159         "_arraySliceExpMinSliceAssign_t", 
    160         "_arraySliceExpMinSliceAssign_u", 
    161         "_arraySliceExpMinSliceAssign_w", 
    162  
    163         "_arraySliceExpMulSliceAddass_d",   // T[] += T[]*T 
    164         "_arraySliceExpMulSliceAddass_f", 
    165         "_arraySliceExpMulSliceAddass_r", 
    166  
    167         "_arraySliceExpMulSliceAssign_d",   // T[]=T[]*T 
    168         "_arraySliceExpMulSliceAssign_f",   // T[]=T[]*T 
    169         "_arraySliceExpMulSliceAssign_i", 
    170         "_arraySliceExpMulSliceAssign_k", 
    171         "_arraySliceExpMulSliceAssign_s", 
    172         "_arraySliceExpMulSliceAssign_t", 
    173         "_arraySliceExpMulSliceAssign_u", 
    174         "_arraySliceExpMulSliceAssign_w", 
    175  
    176         "_arraySliceExpMulSliceMinass_d",   // T[] -= T[]*T 
    177         "_arraySliceExpMulSliceMinass_f", 
    178         "_arraySliceExpMulSliceMinass_r", 
    179  
    180         "_arraySliceSliceAddSliceAssign_a", 
    181         "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[] 
    182         "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[] 
    183         "_arraySliceSliceAddSliceAssign_g", 
    184         "_arraySliceSliceAddSliceAssign_h", 
    185         "_arraySliceSliceAddSliceAssign_i", 
    186         "_arraySliceSliceAddSliceAssign_k", 
    187         "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[] 
    188         "_arraySliceSliceAddSliceAssign_s", 
    189         "_arraySliceSliceAddSliceAssign_t", 
    190         "_arraySliceSliceAddSliceAssign_u", 
    191         "_arraySliceSliceAddSliceAssign_w", 
    192  
    193         "_arraySliceSliceAddass_a", 
    194         "_arraySliceSliceAddass_d",     // T[]+=T[] 
    195         "_arraySliceSliceAddass_f",     // T[]+=T[] 
    196         "_arraySliceSliceAddass_g", 
    197         "_arraySliceSliceAddass_h", 
    198         "_arraySliceSliceAddass_i", 
    199         "_arraySliceSliceAddass_k", 
    200         "_arraySliceSliceAddass_s", 
    201         "_arraySliceSliceAddass_t", 
    202         "_arraySliceSliceAddass_u", 
    203         "_arraySliceSliceAddass_w", 
    204  
    205         "_arraySliceSliceMinSliceAssign_a", 
    206         "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[] 
    207         "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[] 
    208         "_arraySliceSliceMinSliceAssign_g", 
    209         "_arraySliceSliceMinSliceAssign_h", 
    210         "_arraySliceSliceMinSliceAssign_i", 
    211         "_arraySliceSliceMinSliceAssign_k", 
    212         "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[] 
    213         "_arraySliceSliceMinSliceAssign_s", 
    214         "_arraySliceSliceMinSliceAssign_t", 
    215         "_arraySliceSliceMinSliceAssign_u", 
    216         "_arraySliceSliceMinSliceAssign_w", 
    217  
    218         "_arraySliceSliceMinass_a", 
    219         "_arraySliceSliceMinass_d",     // T[]-=T[] 
    220         "_arraySliceSliceMinass_f",     // T[]-=T[] 
    221         "_arraySliceSliceMinass_g", 
    222         "_arraySliceSliceMinass_h", 
    223         "_arraySliceSliceMinass_i", 
    224         "_arraySliceSliceMinass_k", 
    225         "_arraySliceSliceMinass_s", 
    226         "_arraySliceSliceMinass_t", 
    227         "_arraySliceSliceMinass_u", 
    228         "_arraySliceSliceMinass_w", 
    229  
    230         "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[] 
    231         "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[] 
    232         "_arraySliceSliceMulSliceAssign_i", 
    233         "_arraySliceSliceMulSliceAssign_k", 
    234         "_arraySliceSliceMulSliceAssign_s", 
    235         "_arraySliceSliceMulSliceAssign_t", 
    236         "_arraySliceSliceMulSliceAssign_u", 
    237         "_arraySliceSliceMulSliceAssign_w", 
    238  
    239         "_arraySliceSliceMulass_d",     // T[]*=T[] 
    240         "_arraySliceSliceMulass_f",     // T[]*=T[] 
    241         "_arraySliceSliceMulass_i", 
    242         "_arraySliceSliceMulass_k", 
    243         "_arraySliceSliceMulass_s", 
    244         "_arraySliceSliceMulass_t", 
    245         "_arraySliceSliceMulass_u", 
    246         "_arraySliceSliceMulass_w", 
    247     }; 
    248  
    249     int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *)); 
    250     if (i == -1) 
    251     { 
    252 #ifdef DEBUG    // Make sure our array is alphabetized 
    253         for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++) 
    254         { 
    255         if (strcmp(name, libArrayopFuncs[i]) == 0) 
    256             assert(0); 
    257         } 
     67//     /* Some of the array op functions are written as library functions, 
     68//      * presumably to optimize them with special CPU vector instructions. 
     69//      * List those library functions here, in alpha order. 
     70//      */ 
     71//     static const char *libArrayopFuncs[] = 
     72//     { 
     73//         "_arrayExpSliceAddass_a", 
     74//         "_arrayExpSliceAddass_d",       // T[]+=T 
     75//         "_arrayExpSliceAddass_f",       // T[]+=T 
     76//         "_arrayExpSliceAddass_g", 
     77//         "_arrayExpSliceAddass_h", 
     78//         "_arrayExpSliceAddass_i", 
     79//         "_arrayExpSliceAddass_k", 
     80//         "_arrayExpSliceAddass_s", 
     81//         "_arrayExpSliceAddass_t", 
     82//         "_arrayExpSliceAddass_u", 
     83//         "_arrayExpSliceAddass_w", 
     84//  
     85//         "_arrayExpSliceDivass_d",       // T[]/=T 
     86//         "_arrayExpSliceDivass_f",       // T[]/=T 
     87//  
     88//         "_arrayExpSliceMinSliceAssign_a", 
     89//         "_arrayExpSliceMinSliceAssign_d",   // T[]=T-T[] 
     90//         "_arrayExpSliceMinSliceAssign_f",   // T[]=T-T[] 
     91//         "_arrayExpSliceMinSliceAssign_g", 
     92//         "_arrayExpSliceMinSliceAssign_h", 
     93//         "_arrayExpSliceMinSliceAssign_i", 
     94//         "_arrayExpSliceMinSliceAssign_k", 
     95//         "_arrayExpSliceMinSliceAssign_s", 
     96//         "_arrayExpSliceMinSliceAssign_t", 
     97//         "_arrayExpSliceMinSliceAssign_u", 
     98//         "_arrayExpSliceMinSliceAssign_w", 
     99//  
     100//         "_arrayExpSliceMinass_a", 
     101//         "_arrayExpSliceMinass_d",       // T[]-=T 
     102//         "_arrayExpSliceMinass_f",       // T[]-=T 
     103//         "_arrayExpSliceMinass_g", 
     104//         "_arrayExpSliceMinass_h", 
     105//         "_arrayExpSliceMinass_i", 
     106//         "_arrayExpSliceMinass_k", 
     107//         "_arrayExpSliceMinass_s", 
     108//         "_arrayExpSliceMinass_t", 
     109//         "_arrayExpSliceMinass_u", 
     110//         "_arrayExpSliceMinass_w", 
     111//  
     112//         "_arrayExpSliceMulass_d",       // T[]*=T 
     113//         "_arrayExpSliceMulass_f",       // T[]*=T 
     114//         "_arrayExpSliceMulass_i", 
     115//         "_arrayExpSliceMulass_k", 
     116//         "_arrayExpSliceMulass_s", 
     117//         "_arrayExpSliceMulass_t", 
     118//         "_arrayExpSliceMulass_u", 
     119//         "_arrayExpSliceMulass_w", 
     120//  
     121//         "_arraySliceExpAddSliceAssign_a", 
     122//         "_arraySliceExpAddSliceAssign_d",   // T[]=T[]+T 
     123//         "_arraySliceExpAddSliceAssign_f",   // T[]=T[]+T 
     124//         "_arraySliceExpAddSliceAssign_g", 
     125//         "_arraySliceExpAddSliceAssign_h", 
     126//         "_arraySliceExpAddSliceAssign_i", 
     127//         "_arraySliceExpAddSliceAssign_k", 
     128//         "_arraySliceExpAddSliceAssign_s", 
     129//         "_arraySliceExpAddSliceAssign_t", 
     130//         "_arraySliceExpAddSliceAssign_u", 
     131//         "_arraySliceExpAddSliceAssign_w", 
     132//  
     133//         "_arraySliceExpDivSliceAssign_d",   // T[]=T[]/T 
     134//         "_arraySliceExpDivSliceAssign_f",   // T[]=T[]/T 
     135//  
     136//         "_arraySliceExpMinSliceAssign_a", 
     137//         "_arraySliceExpMinSliceAssign_d",   // T[]=T[]-T 
     138//         "_arraySliceExpMinSliceAssign_f",   // T[]=T[]-T 
     139//         "_arraySliceExpMinSliceAssign_g", 
     140//         "_arraySliceExpMinSliceAssign_h", 
     141//         "_arraySliceExpMinSliceAssign_i", 
     142//         "_arraySliceExpMinSliceAssign_k", 
     143//         "_arraySliceExpMinSliceAssign_s", 
     144//         "_arraySliceExpMinSliceAssign_t", 
     145//         "_arraySliceExpMinSliceAssign_u", 
     146//         "_arraySliceExpMinSliceAssign_w", 
     147//  
     148//         "_arraySliceExpMulSliceAddass_d",   // T[] += T[]*T 
     149//         "_arraySliceExpMulSliceAddass_f", 
     150//         "_arraySliceExpMulSliceAddass_r", 
     151//  
     152//         "_arraySliceExpMulSliceAssign_d",   // T[]=T[]*T 
     153//         "_arraySliceExpMulSliceAssign_f",   // T[]=T[]*T 
     154//         "_arraySliceExpMulSliceAssign_i", 
     155//         "_arraySliceExpMulSliceAssign_k", 
     156//         "_arraySliceExpMulSliceAssign_s", 
     157//         "_arraySliceExpMulSliceAssign_t", 
     158//         "_arraySliceExpMulSliceAssign_u", 
     159//         "_arraySliceExpMulSliceAssign_w", 
     160//  
     161//         "_arraySliceExpMulSliceMinass_d",   // T[] -= T[]*T 
     162//         "_arraySliceExpMulSliceMinass_f", 
     163//         "_arraySliceExpMulSliceMinass_r", 
     164//  
     165//         "_arraySliceSliceAddSliceAssign_a", 
     166//         "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[] 
     167//         "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[] 
     168//         "_arraySliceSliceAddSliceAssign_g", 
     169//         "_arraySliceSliceAddSliceAssign_h", 
     170//         "_arraySliceSliceAddSliceAssign_i", 
     171//         "_arraySliceSliceAddSliceAssign_k", 
     172//         "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[] 
     173//         "_arraySliceSliceAddSliceAssign_s", 
     174//         "_arraySliceSliceAddSliceAssign_t", 
     175//         "_arraySliceSliceAddSliceAssign_u", 
     176//         "_arraySliceSliceAddSliceAssign_w", 
     177//  
     178//         "_arraySliceSliceAddass_a", 
     179//         "_arraySliceSliceAddass_d",     // T[]+=T[] 
     180//         "_arraySliceSliceAddass_f",     // T[]+=T[] 
     181//         "_arraySliceSliceAddass_g", 
     182//         "_arraySliceSliceAddass_h", 
     183//         "_arraySliceSliceAddass_i", 
     184//         "_arraySliceSliceAddass_k", 
     185//         "_arraySliceSliceAddass_s", 
     186//         "_arraySliceSliceAddass_t", 
     187//         "_arraySliceSliceAddass_u", 
     188//         "_arraySliceSliceAddass_w", 
     189//  
     190//         "_arraySliceSliceMinSliceAssign_a", 
     191//         "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[] 
     192//         "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[] 
     193//         "_arraySliceSliceMinSliceAssign_g", 
     194//         "_arraySliceSliceMinSliceAssign_h", 
     195//         "_arraySliceSliceMinSliceAssign_i", 
     196//         "_arraySliceSliceMinSliceAssign_k", 
     197//         "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[] 
     198//         "_arraySliceSliceMinSliceAssign_s", 
     199//         "_arraySliceSliceMinSliceAssign_t", 
     200//         "_arraySliceSliceMinSliceAssign_u", 
     201//         "_arraySliceSliceMinSliceAssign_w", 
     202//  
     203//         "_arraySliceSliceMinass_a", 
     204//         "_arraySliceSliceMinass_d",     // T[]-=T[] 
     205//         "_arraySliceSliceMinass_f",     // T[]-=T[] 
     206//         "_arraySliceSliceMinass_g", 
     207//         "_arraySliceSliceMinass_h", 
     208//         "_arraySliceSliceMinass_i", 
     209//         "_arraySliceSliceMinass_k", 
     210//         "_arraySliceSliceMinass_s", 
     211//         "_arraySliceSliceMinass_t", 
     212//         "_arraySliceSliceMinass_u", 
     213//         "_arraySliceSliceMinass_w", 
     214//  
     215//         "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[] 
     216//         "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[] 
     217//         "_arraySliceSliceMulSliceAssign_i", 
     218//         "_arraySliceSliceMulSliceAssign_k", 
     219//         "_arraySliceSliceMulSliceAssign_s", 
     220//         "_arraySliceSliceMulSliceAssign_t", 
     221//         "_arraySliceSliceMulSliceAssign_u", 
     222//         "_arraySliceSliceMulSliceAssign_w", 
     223//  
     224//         "_arraySliceSliceMulass_d",     // T[]*=T[] 
     225//         "_arraySliceSliceMulass_f",     // T[]*=T[] 
     226//         "_arraySliceSliceMulass_i", 
     227//         "_arraySliceSliceMulass_k", 
     228//         "_arraySliceSliceMulass_s", 
     229//         "_arraySliceSliceMulass_t", 
     230//         "_arraySliceSliceMulass_u", 
     231//         "_arraySliceSliceMulass_w", 
     232//     }; 
     233//  
     234//     int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *)); 
     235//     if (i == -1) 
     236//     { 
     237// #ifdef DEBUG    // Make sure our array is alphabetized 
     238//         for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++) 
     239//         { 
     240//         if (strcmp(name, libArrayopFuncs[i]) == 0) 
     241//             assert(0); 
     242//         } 
     243// #endif 
     244 
     245        /* Not in library, so generate it. 
     246         * Construct the function body: 
     247         *  foreach (i; 0 .. p.length)    for (size_t i = 0; i < p.length; i++) 
     248         *      loopbody; 
     249         *  return p; 
     250         */ 
     251 
     252        Arguments *fparams = new Arguments(); 
     253        Expression *loopbody = buildArrayLoop(fparams); 
     254        Argument *p = (Argument *)fparams->data[0 /*fparams->dim - 1*/]; 
     255#if DMDV1 
     256        // for (size_t i = 0; i < p.length; i++) 
     257        Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t)); 
     258        Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init); 
     259        Statement *s1 = new ForStatement(0, 
     260        new DeclarationStatement(0, d), 
     261        new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))), 
     262        new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)), 
     263        new ExpStatement(0, loopbody)); 
     264#else 
     265        // foreach (i; 0 .. p.length) 
     266        Statement *s1 = new ForeachRangeStatement(0, TOKforeach, 
     267        new Argument(0, NULL, Id::p, NULL), 
     268        new IntegerExp(0, 0, Type::tint32), 
     269        new ArrayLengthExp(0, new IdentifierExp(0, p->ident)), 
     270        new ExpStatement(0, loopbody)); 
    258271#endif 
    259         /* Not in library, so generate it. 
    260          * Construct the function body: 
    261          *  foreach (i; 0 .. p.length)    for (size_t i = 0; i < p.length; i++) 
    262          *      loopbody; 
    263          *  return p; 
    264          */ 
    265  
    266         Arguments *fparams = new Arguments(); 
    267         Expression *loopbody = buildArrayLoop(fparams); 
    268         Argument *p = (Argument *)fparams->data[0 /*fparams->dim - 1*/]; 
    269 #if DMDV1 
    270         // for (size_t i = 0; i < p.length; i++) 
    271         Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t)); 
    272         Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init); 
    273         Statement *s1 = new ForStatement(0, 
    274         new DeclarationStatement(0, d), 
    275         new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))), 
    276         new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)), 
    277         new ExpStatement(0, loopbody)); 
    278 #else 
    279         // foreach (i; 0 .. p.length) 
    280         Statement *s1 = new ForeachRangeStatement(0, TOKforeach, 
    281         new Argument(0, NULL, Id::p, NULL), 
    282         new IntegerExp(0, 0, Type::tint32), 
    283         new ArrayLengthExp(0, new IdentifierExp(0, p->ident)), 
    284         new ExpStatement(0, loopbody)); 
    285 #endif 
    286         Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident)); 
    287         //printf("s2: %s\n", s2->toChars()); 
    288         Statement *fbody = new CompoundStatement(0, s1, s2); 
    289  
    290         /* Construct the function 
    291          */ 
    292         TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc); 
    293         //printf("ftype: %s\n", ftype->toChars()); 
    294         fd = new FuncDeclaration(0, 0, Lexer::idPool(name), STCundefined, ftype); 
    295         fd->fbody = fbody; 
    296         fd->protection = PROTpublic; 
    297         fd->linkage = LINKc; 
    298  
    299         sc->module->importedFrom->members->push(fd); 
    300  
    301         sc = sc->push(); 
    302         sc->parent = sc->module->importedFrom; 
    303         sc->stc = 0; 
    304         sc->linkage = LINKc; 
    305         fd->semantic(sc); 
    306         sc->pop(); 
    307     } 
    308     else 
    309     {   /* In library, refer to it. 
    310          */ 
    311         // LDC FIXME    
    312         fd = FuncDeclaration::genCfunc(NULL, type, name); 
    313     } 
    314     sv->ptrvalue = fd;  // cache symbol in hash table 
     272        Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident)); 
     273        //printf("s2: %s\n", s2->toChars()); 
     274        Statement *fbody = new CompoundStatement(0, s1, s2); 
     275 
     276        /* Construct the function 
     277         */ 
     278        TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc); 
     279        //printf("ftype: %s\n", ftype->toChars()); 
     280        fd = new FuncDeclaration(0, 0, Lexer::idPool(name), STCundefined, ftype); 
     281        fd->fbody = fbody; 
     282        fd->protection = PROTprotected; 
     283        fd->linkage = LINKd; 
     284 
     285        // special attention for array ops 
     286        fd->isArrayOp = true; 
     287 
     288        sc->module->members->push(fd); 
     289 
     290        sc = sc->push(); 
     291        sc->parent = sc->module; 
     292        sc->stc = 0; 
     293        sc->linkage = LINKd; 
     294        fd->semantic(sc); 
     295        sc->pop(); 
     296//     } 
     297//     else 
     298//     {   /* In library, refer to it. 
     299//          */ 
     300//         // FIXME 
     301//         fd = FuncDeclaration::genCfunc(NULL, type, name); 
     302//     } 
     303    sv->ptrvalue = fd;  // cache symbol in hash table 
    315304    } 
    316305 
  • dmd/declaration.h

    r663 r703  
    652652    typedef std::map<const char*, LabelStatement*> LabelMap; 
    653653    LabelMap labmap; 
     654 
     655    // if this is an array operation it gets a little special attention 
     656    bool isArrayOp; 
    654657}; 
    655658 
  • dmd/func.c

    r664 r703  
    7878    nrvo_var = NULL; 
    7979    shidden = NULL; 
     80 
     81    // LDC 
     82    isArrayOp = false; 
    8083} 
    8184 
  • dmd/module.h

    r676 r703  
    176176     
    177177    bool llvmForceLogging; 
     178 
     179    // array ops emitted in this module already 
     180    StringTable arrayfuncs; 
    178181}; 
    179182 
  • gen/toir.cpp

    r699 r703  
    471471        DtoAssign(loc, &arrval, slice); 
    472472        return newlen; 
    473     } 
    474     else if (e1->op == TOKslice && !ismemset && 
    475         (e2->op == TOKadd || e2->op == TOKmin || 
    476         e2->op == TOKmul || e2->op == TOKdiv || 
    477         e2->op == TOKmod || e2->op == TOKxor || 
    478         e2->op == TOKand || e2->op == TOKor  || 
    479         e2->op == TOKtilde || e2->op == TOKneg)) 
    480     { 
    481         assert(0 && "array op assignment is TODO"); 
    482473    } 
    483474 
  • gen/tollvm.cpp

    r661 r703  
    281281        TypeFunction* ft = (TypeFunction*)fdecl->type; 
    282282 
     283        // array operations are always internal 
     284        if (fdecl->isArrayOp) 
     285            return llvm::GlobalValue::InternalLinkage; 
    283286        // intrinsics are always external 
    284287        if (fdecl->llvmInternal == LLVMintrinsic) 
  • premake.lua

    r699 r703  
    3232    TRIPLE = options["target-override"] 
    3333else 
    34     local p = io.popen("./config.guess") 
     34    local p = io.popen("sh config.guess") 
    3535    TRIPLE = p:read() 
    3636end 
Copyright © 2008, LDC Development Team.