Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 258

Show
Ignore:
Timestamp:
11/21/09 10:55:39 (15 years ago)
Author:
walter
Message:

bugzilla 3407

Files:

Legend:

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

    r253 r258  
    25562556        printf("elwr\n"); 
    25572557        elem_print(elwr); 
    25582558        printf("eupr\n"); 
    25592559        elem_print(eupr); 
    25602560        printf("enbytes\n"); 
    25612561        elem_print(enbytes); 
    25622562#endif 
    25632563        einit = el_combine(n1x, einit); 
    25642564        einit = el_combine(einit, elwrx); 
    25652565        einit = el_combine(einit, euprx); 
    25662566 
    25672567        evalue = this->e2->toElem(irs); 
    25682568 
    25692569#if 0 
    25702570        printf("n1\n"); 
    25712571        elem_print(n1); 
    25722572        printf("enbytes\n"); 
    25732573        elem_print(enbytes); 
    25742574#endif 
    25752575 
    2576         if (global.params.useArrayBounds && eupr && ta->ty != Tpointer) 
     2576        if (irs->arrayBoundsCheck() && eupr && ta->ty != Tpointer) 
    25772577        { 
    25782578        elem *c1; 
    25792579        elem *c2; 
    25802580        elem *ea; 
    25812581        elem *eb; 
    25822582        elem *enbytesx; 
    25832583 
    25842584        assert(elwr); 
    25852585        enbytesx = enbytes; 
    25862586        enbytes = el_same(&enbytesx); 
    25872587        c1 = el_bin(OPle, TYint, el_copytree(eupr), enbytesx); 
    25882588        c2 = el_bin(OPle, TYint, el_copytree(elwr), el_copytree(eupr)); 
    25892589        c1 = el_bin(OPandand, TYint, c1, c2); 
    25902590 
    25912591        // Construct: (c1 || ModuleArray(line)) 
    25922592        Symbol *sassert; 
    25932593 
    25942594        sassert = irs->blx->module->toModuleArray(); 
    25952595        ea = el_bin(OPcall,TYvoid,el_var(sassert), el_long(TYint, loc.linnum)); 
    25962596        eb = el_bin(OPoror,TYvoid,c1,ea); 
     
    26612661    { 
    26622662        /* It's array1[]=array2[] 
    26632663         * which is a memcpy 
    26642664         */ 
    26652665        elem *ep; 
    26662666 
    26672667        elem *eto = e1->toElem(irs); 
    26682668        elem *efrom = e2->toElem(irs); 
    26692669 
    26702670        unsigned size = t1->nextOf()->size(); 
    26712671        elem *esize = el_long(TYint, size); 
    26722672 
    26732673        /* Determine if we need to do postblit 
    26742674         */ 
    26752675        int postblit = 0; 
    26762676        if (needsPostblit(t1)) 
    26772677        postblit = 1; 
    26782678 
    26792679        assert(e2->type->ty != Tpointer); 
    26802680 
    2681         if (!postblit && !global.params.useArrayBounds
     2681        if (!postblit && !irs->arrayBoundsCheck()
    26822682        { 
    26832683        elem *ex = el_same(&eto); 
    26842684 
    26852685        // Determine if elen is a constant 
    26862686        elem *elen; 
    26872687        if (eto->Eoper == OPpair && 
    26882688            eto->E1->Eoper == OPconst) 
    26892689        { 
    26902690            elen = el_copytree(eto->E1); 
    26912691        } 
    26922692        else 
    26932693        { 
    26942694            // It's not a constant, so pull it from the dynamic array 
    26952695            elen = el_una(OP64_32, TYint, el_copytree(ex)); 
    26962696        } 
    26972697 
    26982698        esize = el_bin(OPmul, TYint, elen, esize); 
    26992699        elem *epto = array_toPtr(e1->type, ex); 
    27002700        elem *epfr = array_toPtr(e2->type, efrom); 
    27012701#if 1 
     
    42114211{ 
    42124212    //printf("SliceExp::toElem()\n"); 
    42134213    Type *t1 = e1->type->toBasetype(); 
    42144214    elem *e = e1->toElem(irs); 
    42154215    if (lwr) 
    42164216    { 
    42174217    elem *einit = resolveLengthVar(lengthVar, &e, t1); 
    42184218 
    42194219    int sz = t1->nextOf()->size(); 
    42204220 
    42214221    elem *elwr = lwr->toElem(irs); 
    42224222    elem *eupr = upr->toElem(irs); 
    42234223 
    42244224    elem *elwr2 = el_same(&elwr); 
    42254225 
    42264226    // Create an array reference where: 
    42274227    // length is (upr - lwr) 
    42284228    // pointer is (ptr + lwr*sz) 
    42294229    // Combine as (length pair ptr) 
    42304230 
    4231     if (global.params.useArrayBounds
     4231    if (irs->arrayBoundsCheck()
    42324232    { 
    42334233        // Checks (unsigned compares): 
    42344234        //  upr <= array.length 
    42354235        //  lwr <= upr 
    42364236 
    42374237        elem *c1; 
    42384238        elem *c2; 
    42394239        elem *ea; 
    42404240        elem *eb; 
    42414241        elem *eupr2; 
    42424242        elem *elength; 
    42434243 
    42444244        if (t1->ty == Tpointer) 
    42454245        { 
    42464246        // Just do lwr <= upr check 
    42474247 
    42484248        eupr2 = el_same(&eupr); 
    42494249        eupr2->Ety = TYuint;            // make sure unsigned comparison 
    42504250        c1 = el_bin(OPle, TYint, elwr2, eupr2); 
    42514251        c1 = el_combine(eupr, c1); 
     
    43404340        assert(n2->Enumbytes); 
    43414341    } 
    43424342    elem *valuesize = el_long(TYuint, vsize);   // BUG: should be TYsize_t 
    43434343    //printf("valuesize: "); elem_print(valuesize); 
    43444344    if (modifiable) 
    43454345    { 
    43464346        n1 = el_una(OPaddr, TYnptr, n1); 
    43474347        s = taa->aaGetSymbol("Get", 1); 
    43484348    } 
    43494349    else 
    43504350    { 
    43514351        s = taa->aaGetSymbol("GetRvalue", 1); 
    43524352    } 
    43534353    //printf("taa->index = %s\n", taa->index->toChars()); 
    43544354    keyti = taa->index->getInternalTypeInfo(NULL)->toElem(irs); 
    43554355    //keyti = taa->index->getTypeInfo(NULL)->toElem(irs); 
    43564356    //printf("keyti:\n"); 
    43574357    //elem_print(keyti); 
    43584358    ep = el_params(n2, valuesize, keyti, n1, NULL); 
    43594359    e = el_bin(OPcall, TYnptr, el_var(s), ep); 
    4360     if (global.params.useArrayBounds
     4360    if (irs->arrayBoundsCheck()
    43614361    { 
    43624362        elem *ea; 
    43634363 
    43644364        elem *n = el_same(&e); 
    43654365 
    43664366        // Construct: ((e || ModuleAssert(line)),n) 
    43674367        Symbol *sassert = irs->blx->module->toModuleArray(); 
    43684368        ea = el_bin(OPcall,TYvoid,el_var(sassert), 
    43694369        el_long(TYint, loc.linnum)); 
    43704370        e = el_bin(OPoror,TYvoid,e,ea); 
    43714371        e = el_bin(OPcomma, TYnptr, e, n); 
    43724372    } 
    43734373    e = el_una(OPind, type->totym(), e); 
    43744374    if (tybasic(e->Ety) == TYstruct) 
    43754375        e->Enumbytes = type->size(); 
    43764376    } 
    43774377    else 
    43784378    { 
    43794379    elem *einit = resolveLengthVar(lengthVar, &n1, t1); 
    43804380    elem *n2 = e2->toElem(irs); 
    43814381 
    4382     if (global.params.useArrayBounds
     4382    if (irs->arrayBoundsCheck()
    43834383    { 
    43844384        elem *elength; 
    43854385        elem *n2x; 
    43864386        elem *ea; 
    43874387 
    43884388        if (t1->ty == Tsarray) 
    43894389        {   TypeSArray *tsa = (TypeSArray *)t1; 
    43904390        dinteger_t length = tsa->dim->toInteger(); 
    43914391 
    43924392        elength = el_long(TYuint, length); 
    43934393        goto L1; 
    43944394        } 
    43954395        else if (t1->ty == Tarray) 
    43964396        { 
    43974397        elength = n1; 
    43984398        n1 = el_same(&elength); 
    43994399        elength = el_una(OP64_32, TYuint, elength); 
    44004400        L1: 
    44014401        n2x = n2; 
    44024402        n2 = el_same(&n2x); 
  • trunk/src/irstate.c

    r189 r258  
    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 
    66// http://www.digitalmars.com 
    77 
    88#include <stdio.h> 
    99 
     10#include "mars.h" 
     11#include "mtype.h" 
     12#include "declaration.h" 
    1013#include "irstate.h" 
    1114 
    1215IRState::IRState(IRState *irs, Statement *s) 
    1316{ 
    1417    prev = irs; 
    1518    statement = s; 
    1619    symbol = NULL; 
    1720    breakBlock = NULL; 
    1821    contBlock = NULL; 
    1922    switchBlock = NULL; 
    2023    defaultBlock = NULL; 
    2124    ident = NULL; 
    2225    ehidden = NULL; 
    2326    startaddress = NULL; 
    2427    if (irs) 
    2528    { 
    2629    m = irs->m; 
    2730    shidden = irs->shidden; 
    2831    sclosure = irs->sclosure; 
    2932    sthis = irs->sthis; 
     
    145148 
    146149    for (bc = this; bc; bc = bc->prev) 
    147150    { 
    148151    if (bc->defaultBlock) 
    149152        return bc->defaultBlock; 
    150153    } 
    151154    return NULL; 
    152155} 
    153156 
    154157FuncDeclaration *IRState::getFunc() 
    155158{ 
    156159    IRState *bc; 
    157160 
    158161    for (bc = this; bc->prev; bc = bc->prev) 
    159162    { 
    160163    } 
    161164    return (FuncDeclaration *)(bc->symbol); 
    162165} 
    163166 
    164167 
     168/********************** 
     169 * Return !=0 if do array bounds checking 
     170 */ 
     171int IRState::arrayBoundsCheck() 
     172{ 
     173    int result = global.params.useArrayBounds; 
     174 
     175    if (result == 1) 
     176    {   // For safe functions only 
     177    result = 0; 
     178    FuncDeclaration *fd = getFunc(); 
     179    if (fd) 
     180    {   Type *t = fd->type; 
     181        if (t->ty == Tfunction && ((TypeFunction *)t)->trust == TRUSTsafe) 
     182        result = 1; 
     183    } 
     184    } 
     185    return result; 
     186} 
  • trunk/src/irstate.h

    r189 r258  
    3535    Symbol *sclosure;       // pointer to closure instance 
    3636    Blockx *blx; 
    3737    Array *deferToObj;      // array of Dsymbol's to run toObjFile(int multiobj) on later 
    3838    elem *ehidden;      // transmit hidden pointer to CallExp::toElem() 
    3939    Symbol *startaddress; 
    4040 
    4141    block *breakBlock; 
    4242    block *contBlock; 
    4343    block *switchBlock; 
    4444    block *defaultBlock; 
    4545 
    4646    IRState(IRState *irs, Statement *s); 
    4747    IRState(IRState *irs, Dsymbol *s); 
    4848    IRState(Module *m, Dsymbol *s); 
    4949 
    5050    block *getBreakBlock(Identifier *ident); 
    5151    block *getContBlock(Identifier *ident); 
    5252    block *getSwitchBlock(); 
    5353    block *getDefaultBlock(); 
    5454    FuncDeclaration *getFunc(); 
     55    int arrayBoundsCheck(); 
    5556}; 
    5657 
    5758#endif /* DMD_CONTEXT_H */ 
  • trunk/src/mars.c

    r242 r258  
    219219  -d             allow deprecated features\n\ 
    220220  -debug         compile in debug code\n\ 
    221221  -debug=level   compile in debug code <= level\n\ 
    222222  -debug=ident   compile in debug code identified by ident\n\ 
    223223  -debuglib=name    set symbolic debug library to name\n\ 
    224224  -defaultlib=name  set default library to name\n\ 
    225225  -deps=filename write module dependencies to filename\n\ 
    226226  -g             add symbolic debug info\n\ 
    227227  -gc            add symbolic debug info, pretend to be C\n\ 
    228228  -H             generate 'header' file\n\ 
    229229  -Hddirectory   write 'header' file to directory\n\ 
    230230  -Hffilename    write 'header' file to filename\n\ 
    231231  --help         print help\n\ 
    232232  -Ipath         where to look for imports\n\ 
    233233  -ignore        ignore unsupported pragmas\n\ 
    234234  -inline        do function inlining\n\ 
    235235  -Jpath         where to look for string imports\n\ 
    236236  -Llinkerflag   pass linkerflag to link\n\ 
    237237  -lib           generate library rather than object files\n\ 
    238238  -man           open web browser on manual page\n\ 
     239  -noboundscheck turns off array bounds checking for all functions\n\ 
    239240  -nofloat       do not emit reference to floating point\n\ 
    240241  -O             optimize\n\ 
    241242  -o-            do not write object file\n\ 
    242243  -odobjdir      write object & library files to directory objdir\n\ 
    243244  -offilename    name output file to filename\n\ 
    244245  -op            do not strip paths from source file\n\ 
    245246  -profile   profile runtime performance of generated code\n\ 
    246247  -quiet         suppress unnecessary messages\n\ 
    247248  -release   compile release version\n\ 
    248249  -run srcfile args...   run resulting program, passing args\n\ 
    249   -safe          safe memory model\n\ 
    250250  -unittest      compile in unit tests\n\ 
    251251  -v             verbose\n\ 
    252252  -version=level compile in version code >= level\n\ 
    253253  -version=ident compile in version code identified by ident\n\ 
    254254  -vtls          list all variables going into thread local storage\n\ 
    255255  -w             enable warnings\n\ 
    256256  -X             generate JSON file\n\ 
    257257  -Xffilename    write JSON file to filename\n\ 
    258258"); 
    259259} 
    260260 
    261261int main(int argc, char *argv[]) 
    262262{ 
    263263    int i; 
    264264    Array files; 
    265265    Array libmodules; 
    266266    char *p; 
    267267    Module *m; 
    268268    int status = EXIT_SUCCESS; 
    269269    int argcstart = argc; 
    270270    int setdebuglib = 0; 
     271    char noboundscheck = 0; 
    271272 
    272273    // Check for malformed input 
    273274    if (argc < 1 || !argv) 
    274275    { 
    275276      Largs: 
    276277    error("missing or null command line arguments"); 
    277278    fatal(); 
    278279    } 
    279280    for (i = 0; i < argc; i++) 
    280281    { 
    281282    if (!argv[i]) 
    282283        goto Largs; 
    283284    } 
    284285 
    285286    if (response_expand(&argc,&argv))   // expand response files 
    286287    error("can't open response file"); 
    287288 
    288289    files.reserve(argc - 1); 
    289290 
    290291    // Set default values 
    291292    global.params.argv0 = argv[0]; 
    292293    global.params.link = 1; 
    293294    global.params.useAssert = 1; 
    294295    global.params.useInvariants = 1; 
    295296    global.params.useIn = 1; 
    296297    global.params.useOut = 1; 
    297     global.params.useArrayBounds = 1; 
     298    global.params.useArrayBounds = 2;  // default to all functions 
    298299    global.params.useSwitchError = 1; 
    299300    global.params.useInline = 0; 
    300301    global.params.obj = 1; 
    301302    global.params.Dversion = 2; 
    302303    global.params.quiet = 1; 
    303304 
    304305    global.params.linkswitches = new Array(); 
    305306    global.params.libfiles = new Array(); 
    306307    global.params.objfiles = new Array(); 
    307308    global.params.ddocfiles = new Array(); 
    308309 
    309310#if TARGET_WINDOS 
    310311    global.params.defaultlibname = "phobos"; 
    311312#elif TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS 
    312313    global.params.defaultlibname = "phobos2"; 
    313314#elif TARGET_NET 
    314315#else 
    315316#error "fix this" 
    316317#endif 
    317318 
     
    513514            case 0: 
    514515            break; 
    515516 
    516517            default: 
    517518            goto Lerror; 
    518519        } 
    519520        } 
    520521        else if (strcmp(p + 1, "ignore") == 0) 
    521522        global.params.ignoreUnsupportedPragmas = 1; 
    522523        else if (strcmp(p + 1, "inline") == 0) 
    523524        global.params.useInline = 1; 
    524525        else if (strcmp(p + 1, "lib") == 0) 
    525526        global.params.lib = 1; 
    526527        else if (strcmp(p + 1, "nofloat") == 0) 
    527528        global.params.nofloat = 1; 
    528529        else if (strcmp(p + 1, "quiet") == 0) 
    529530        global.params.quiet = 1; 
    530531        else if (strcmp(p + 1, "release") == 0) 
    531532        global.params.release = 1; 
    532533#if DMDV2 
    533         else if (strcmp(p + 1, "safe") == 0) 
    534         global.params.safe = 1;        // now ignored 
     534        else if (strcmp(p + 1, "noboundscheck") == 0) 
     535        noboundscheck = 1; 
    535536#endif 
    536537        else if (strcmp(p + 1, "unittest") == 0) 
    537538        global.params.useUnitTests = 1; 
    538539        else if (p[1] == 'I') 
    539540        { 
    540541        if (!global.params.imppath) 
    541542            global.params.imppath = new Array(); 
    542543        global.params.imppath->push(p + 2); 
    543544        } 
    544545        else if (p[1] == 'J') 
    545546        { 
    546547        if (!global.params.fileImppath) 
    547548            global.params.fileImppath = new Array(); 
    548549        global.params.fileImppath->push(p + 2); 
    549550        } 
    550551        else if (memcmp(p + 1, "debug", 5) == 0 && p[6] != 'l') 
    551552        { 
    552553        // Parse: 
    553554        //  -debug 
    554555        //  -debug=number 
     
    709710    { 
    710711    fatal(); 
    711712    } 
    712713    if (files.dim == 0) 
    713714    {   usage(); 
    714715    return EXIT_FAILURE; 
    715716    } 
    716717 
    717718    if (!setdebuglib) 
    718719    global.params.debuglibname = global.params.defaultlibname; 
    719720 
    720721#if TARGET_OSX 
    721722    global.params.pic = 1; 
    722723#endif 
    723724 
    724725    if (global.params.release) 
    725726    {   global.params.useInvariants = 0; 
    726727    global.params.useIn = 0; 
    727728    global.params.useOut = 0; 
    728729    global.params.useAssert = 0; 
     730    global.params.useArrayBounds = 1; 
     731    global.params.useSwitchError = 0; 
     732    } 
     733    if (noboundscheck) 
    729734    global.params.useArrayBounds = 0; 
    730     global.params.useSwitchError = 0; 
    731     } 
    732735 
    733736    if (global.params.run) 
    734737    global.params.quiet = 1; 
    735738 
    736739    if (global.params.useUnitTests) 
    737740    global.params.useAssert = 1; 
    738741 
    739742    if (!global.params.obj || global.params.lib) 
    740743    global.params.link = 0; 
    741744 
    742745    if (global.params.link) 
    743746    { 
    744747    global.params.exefile = global.params.objname; 
    745748    global.params.oneobj = 1; 
    746749    if (global.params.objname) 
    747750    { 
    748751        /* Use this to name the one object file with the same 
    749752         * name as the exe file. 
    750753         */ 
    751754        global.params.objname = FileName::forceExt(global.params.objname, global.obj_ext)->toChars(); 
  • trunk/src/mars.h

    r242 r258  
    123123    char oneobj;    // write one object file instead of multiple ones 
    124124    char trace;     // insert profiling hooks 
    125125    char quiet;     // suppress non-error messages 
    126126    char verbose;   // verbose compile 
    127127    char vtls;      // identify thread local variables 
    128128    char symdebug;  // insert debug symbolic information 
    129129    char optimize;  // run optimizer 
    130130    char cpu;       // target CPU 
    131131    char isX86_64;  // generate X86_64 bit code 
    132132    char isLinux;   // generate code for linux 
    133133    char isOSX;     // generate code for Mac OSX 
    134134    char isWindows; // generate code for Windows 
    135135    char isFreeBSD; // generate code for FreeBSD 
    136136    char isSolaris; // generate code for Solaris 
    137137    char scheduler; // which scheduler to use 
    138138    char useDeprecated; // allow use of deprecated features 
    139139    char useAssert; // generate runtime code for assert()'s 
    140140    char useInvariants; // generate class invariant checks 
    141141    char useIn;     // generate precondition checks 
    142142    char useOut;    // generate postcondition checks 
    143     char useArrayBounds; // generate array bounds checks 
     143    char useArrayBounds; // 0: no array bounds checks 
     144             // 1: array bounds checks for safe functions only 
     145             // 2: array bounds checks for all functions 
     146    char noboundscheck; // no array bounds checking at all 
    144147    char useSwitchError; // check for switches without a default 
    145148    char useUnitTests;  // generate unittest code 
    146149    char useInline; // inline expand functions 
    147150    char release;   // build release version 
    148151    char preservePaths; // !=0 means don't strip path from source file 
    149152    char warnings;  // enable warnings 
    150153    char pic;       // generate position-independent-code for shared libs 
    151154    char cov;       // generate code coverage data 
    152155    char nofloat;   // code should not pull in floating point support 
    153156    char Dversion;  // D version number 
    154157    char ignoreUnsupportedPragmas;  // rather than error on them 
    155     char safe;      // enforce safe memory model 
    156158 
    157159    char *argv0;    // program name 
    158160    Array *imppath; // array of char*'s of where to look for import modules 
    159161    Array *fileImppath; // array of char*'s of where to look for file import modules 
    160162    char *objdir;   // .obj/.lib file output directory 
    161163    char *objname;  // .obj file output name 
    162164    char *libname;  // .lib file output name 
    163165 
    164166    char doDocComments; // process embedded documentation comments 
    165167    char *docdir;   // write documentation file to docdir directory 
    166168    char *docname;  // write documentation file to docname 
    167169    Array *ddocfiles;   // macro include files for Ddoc 
    168170 
    169171    char doHdrGeneration;   // process embedded documentation comments 
    170172    char *hdrdir;       // write 'header' file to docdir directory 
    171173    char *hdrname;      // write 'header' file to docname 
    172174 
    173175    char doXGeneration;     // write JSON file 
    174176    char *xfilename;        // write JSON file to xfilename 
    175177 
  • trunk/src/win32.mak

    r204 r258  
    244244 
    245245cod1.obj : $C\rtlsym.h $C\cod1.c 
    246246    $(CC) -c $(MFLAGS) $C\cod1 
    247247 
    248248cod2.obj : $C\rtlsym.h $C\cod2.c 
    249249    $(CC) -c $(MFLAGS) $C\cod2 
    250250 
    251251cod3.obj : $C\rtlsym.h $C\cod3.c 
    252252    $(CC) -c $(MFLAGS) $C\cod3 
    253253 
    254254cod4.obj : $C\cod4.c 
    255255    $(CC) -c $(MFLAGS) $C\cod4 
    256256 
    257257cod5.obj : $C\cod5.c 
    258258    $(CC) -c $(MFLAGS) $C\cod5 
    259259 
    260260code.obj : $C\code.c 
    261261    $(CC) -c $(MFLAGS) $C\code 
    262262 
    263263irstate.obj : irstate.h irstate.c 
    264     $(CC) -c $(MFLAGS) irstate 
     264    $(CC) -c $(MFLAGS) -I$(ROOT) irstate 
    265265 
    266266csymbol.obj : $C\symbol.c 
    267267    $(CC) -c $(MFLAGS) $C\symbol -ocsymbol.obj 
    268268 
    269269debug.obj : $C\debug.c 
    270270    $(CC) -c $(MFLAGS) -I. $C\debug 
    271271 
    272272dt.obj : $C\dt.h $C\dt.c 
    273273    $(CC) -c $(MFLAGS) $C\dt 
    274274 
    275275ee.obj : $C\ee.c 
    276276    $(CC) -c $(MFLAGS) $C\ee 
    277277 
    278278eh.obj : $C\cc.h $C\code.h $C\type.h $C\dt.h eh.c 
    279279    $(CC) -c $(MFLAGS) eh 
    280280 
    281281el.obj : $C\rtlsym.h $C\el.h $C\el.c 
    282282    $(CC) -c $(MFLAGS) $C\el 
    283283 
    284284evalu8.obj : $C\evalu8.c