Changeset 522
- Timestamp:
- 04/19/07 18:21:35 (1 year ago)
- Files:
-
- trunk/docs/README.software_engineers (modified) (1 diff)
- trunk/rebuild/README (modified) (1 diff)
- trunk/rebuild/cast.c (modified) (2 diffs)
- trunk/rebuild/constfold.c (modified) (2 diffs)
- trunk/rebuild/declaration.c (modified) (1 diff)
- trunk/rebuild/expression.c (modified) (5 diffs)
- trunk/rebuild/expression.h (modified) (1 diff)
- trunk/rebuild/interpret.c (modified) (8 diffs)
- trunk/rebuild/link.c (modified) (5 diffs)
- trunk/rebuild/mars.c (modified) (6 diffs)
- trunk/rebuild/mtype.c (modified) (4 diffs)
- trunk/rebuild/opover.c (modified) (2 diffs)
- trunk/rebuild/optimize.c (modified) (3 diffs)
- trunk/rebuild/parse.c (modified) (7 diffs)
- trunk/rebuild/port.h (modified) (1 diff)
- trunk/rebuild/statement.c (modified) (1 diff)
- trunk/sss/build.d (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/docs/README.software_engineers
r521 r522 94 94 section. 95 95 96 * prebuild, preinstall, preclean, postbuild, postinstall, postclean 97 * Commands to be run before/after building/installing/cleaning the current 98 section. Can be any number of ;-separated commands, and supports some 99 special command types: 96 * prebuild, preinstall, preclean, predigen, postbuild, postinstall, postclean, 97 postdigen 98 * Commands to be run before or after (pre or post) building (build), 99 installing (install), cleaning (clean) or generating .di files (digen) for 100 the current section. Can be any number of ;-separated commands, and 101 supports some special command types: 100 102 * .d files. If a .d file is specified as a command, it will be compiled and 101 103 run. trunk/rebuild/README
r509 r522 80 80 path=<path> Adds <path> to $PATH (or %PATH%) during each rebuild 81 81 run. 82 flags=<flags> Acts as though <flags> were passed with every rebuild 83 run. trunk/rebuild/cast.c
r459 r522 404 404 } 405 405 406 int AssocArrayLiteralExp::implicitConvTo(Type *t) 407 { MATCH result = MATCHexact; 408 409 Type *typeb = type->toBasetype(); 410 Type *tb = t->toBasetype(); 411 if (tb->ty == Taarray && typeb->ty == Taarray) 412 { 413 for (size_t i = 0; i < keys->dim; i++) 414 { Expression *e = (Expression *)keys->data[i]; 415 MATCH m = (MATCH)e->implicitConvTo(((TypeAArray *)tb)->key); 416 if (m < result) 417 result = m; // remember worst match 418 if (result == MATCHnomatch) 419 break; // no need to check for worse 420 e = (Expression *)values->data[i]; 421 m = (MATCH)e->implicitConvTo(tb->next); 422 if (m < result) 423 result = m; // remember worst match 424 if (result == MATCHnomatch) 425 break; // no need to check for worse 426 } 427 return result; 428 } 429 else 430 return Expression::implicitConvTo(t); 431 } 432 406 433 int AddrExp::implicitConvTo(Type *t) 407 434 { … … 919 946 { 920 947 type = typeb->next->pointerTo(); 948 } 949 L1: 950 return Expression::castTo(sc, t); 951 } 952 953 Expression *AssocArrayLiteralExp::castTo(Scope *sc, Type *t) 954 { 955 Type *typeb = type->toBasetype(); 956 Type *tb = t->toBasetype(); 957 if (tb->ty == Taarray && typeb->ty == Taarray && 958 tb->next->toBasetype()->ty != Tvoid) 959 { 960 assert(keys->dim == values->dim); 961 for (size_t i = 0; i < keys->dim; i++) 962 { Expression *e = (Expression *)values->data[i]; 963 e = e->castTo(sc, tb->next); 964 values->data[i] = (void *)e; 965 966 e = (Expression *)keys->data[i]; 967 e = e->castTo(sc, ((TypeAArray *)tb)->key); 968 keys->data[i] = (void *)e; 969 } 970 type = t; 971 return this; 921 972 } 922 973 L1: trunk/rebuild/constfold.c
r459 r522 1019 1019 e = new IntegerExp(loc, dim, type); 1020 1020 } 1021 else if (e1->op == TOKassocarrayliteral) 1022 { AssocArrayLiteralExp *ale = (AssocArrayLiteralExp *)e1; 1023 size_t dim = ale->keys->dim; 1024 1025 e = new IntegerExp(loc, dim, type); 1026 } 1021 1027 else 1022 1028 e = EXP_CANT_INTERPRET; … … 1088 1094 { e = (Expression *)ale->elements->data[i]; 1089 1095 e->type = type; 1096 } 1097 } 1098 } 1099 else if (e1->op == TOKassocarrayliteral && !e1->checkSideEffect(2)) 1100 { 1101 AssocArrayLiteralExp *ae = (AssocArrayLiteralExp *)e1; 1102 /* Search the keys backwards, in case there are duplicate keys 1103 */ 1104 for (size_t i = ae->keys->dim; i;) 1105 { 1106 i--; 1107 Expression *ekey = (Expression *)ae->keys->data[i]; 1108 Expression *ex = Equal(TOKequal, Type::tbool, ekey, e2); 1109 if (ex == EXP_CANT_INTERPRET) 1110 return ex; 1111 if (ex->isBool(TRUE)) 1112 { e = (Expression *)ae->values->data[i]; 1113 e->type = type; 1114 break; 1090 1115 } 1091 1116 } trunk/rebuild/declaration.c
r461 r522 597 597 { 598 598 //printf("VarDeclaration::semantic('%s', parent = '%s')\n", toChars(), sc->parent->toChars()); 599 //printf("type = %s\n", type->toChars()); 600 //printf("linkage = %d\n", sc->linkage); 599 601 //if (strcmp(toChars(), "mul") == 0) halt(); 600 602 trunk/rebuild/expression.c
r461 r522 43 43 #endif 44 44 45 #include "port.h"45 //#include "port.h" 46 46 #include "mtype.h" 47 47 #include "init.h" … … 3416 3416 exps->push(e); 3417 3417 } 3418 else if (o->dyncast() == DYNCAST_TYPE) 3419 { 3420 Type *t = (Type *)o; 3421 Expression *e = new TypeExp(loc, t); 3422 exps->push(e); 3423 } 3418 3424 else 3419 3425 { … … 4175 4181 Expression *CompileExp::semantic(Scope *sc) 4176 4182 { 4177 #if 1 ||LOGSEMANTIC4183 #if LOGSEMANTIC 4178 4184 printf("CompileExp::semantic('%s')\n", toChars()); 4179 4185 #endif … … 4181 4187 e1 = resolveProperties(sc, e1); 4182 4188 e1 = e1->optimize(WANTvalue | WANTinterpret); 4183 e1->print();4184 4189 if (e1->op != TOKstring) 4185 4190 { //error("argument to mixin must be a string, not (%s)", e1->toChars()); … … 5924 5929 } 5925 5930 } 5926 return e1->castTo(sc, to); 5931 e = e1->castTo(sc, to); 5932 return e; 5927 5933 } 5928 5934 trunk/rebuild/expression.h
r461 r522 368 368 Expression *optimize(int result); 369 369 Expression *interpret(InterState *istate); 370 int implicitConvTo(Type *t); 371 Expression *castTo(Scope *sc, Type *t); 370 372 371 373 int inlineCost(InlineCostState *ics); trunk/rebuild/interpret.c
r461 r522 992 992 993 993 Expression *AssocArrayLiteralExp::interpret(InterState *istate) 994 { Expressions *keysx = NULL;995 Expressions *valuesx = NULL;994 { Expressions *keysx = keys; 995 Expressions *valuesx = values; 996 996 997 997 #if LOG … … 1005 1005 ex = ekey->interpret(istate); 1006 1006 if (ex == EXP_CANT_INTERPRET) 1007 { delete keysx; 1008 delete valuesx; 1009 return EXP_CANT_INTERPRET; 1010 } 1007 goto Lerr; 1011 1008 1012 1009 /* If any changes, do Copy On Write … … 1014 1011 if (ex != ekey) 1015 1012 { 1016 if (!keysx) 1017 { keysx = new Expressions(); 1018 keysx->setDim(keys->dim); 1019 for (size_t j = 0; j < i; j++) 1020 { 1021 keysx->data[j] = keys->data[j]; 1022 } 1023 } 1013 if (keysx == keys) 1014 keysx = (Expressions *)keys->copy(); 1024 1015 keysx->data[i] = (void *)ex; 1025 1016 } … … 1027 1018 ex = evalue->interpret(istate); 1028 1019 if (ex == EXP_CANT_INTERPRET) 1029 { delete keysx; 1030 delete valuesx; 1031 return EXP_CANT_INTERPRET; 1032 } 1020 goto Lerr; 1033 1021 1034 1022 /* If any changes, do Copy On Write … … 1036 1024 if (ex != evalue) 1037 1025 { 1038 if (!valuesx) 1039 { valuesx = new Expressions(); 1040 valuesx->setDim(values->dim); 1041 for (size_t j = 0; j < i; j++) 1042 { 1043 valuesx->data[j] = values->data[j]; 1044 } 1045 } 1026 if (valuesx == values) 1027 valuesx = (Expressions *)values->copy(); 1046 1028 valuesx->data[i] = (void *)ex; 1047 1029 } 1048 1030 } 1049 if (keysx || valuesx) 1050 { 1051 if (keysx) 1052 expandTuples(keysx); 1053 if (valuesx) 1054 expandTuples(valuesx); 1055 if ((keysx && keysx->dim != keys->dim) || 1056 (valuesx && valuesx->dim != values->dim)) 1057 { delete keysx; 1058 delete valuesx; 1059 return EXP_CANT_INTERPRET; 1060 } 1061 AssocArrayLiteralExp *ae = new AssocArrayLiteralExp(loc, 1062 keysx ? keysx : keys, valuesx ? valuesx : values); 1031 if (keysx != keys) 1032 expandTuples(keysx); 1033 if (valuesx != values) 1034 expandTuples(valuesx); 1035 if (keysx->dim != valuesx->dim) 1036 goto Lerr; 1037 1038 /* Remove duplicate keys 1039 */ 1040 for (size_t i = 1; i < keysx->dim; i++) 1041 { Expression *ekey = (Expression *)keysx->data[i - 1]; 1042 1043 for (size_t j = i; j < keysx->dim; j++) 1044 { Expression *ekey2 = (Expression *)keysx->data[j]; 1045 Expression *ex = Equal(TOKequal, Type::tbool, ekey, ekey2); 1046 if (ex == EXP_CANT_INTERPRET) 1047 goto Lerr; 1048 if (ex->isBool(TRUE)) // if a match 1049 { 1050 // Remove ekey 1051 if (keysx == keys) 1052 keysx = (Expressions *)keys->copy(); 1053 if (valuesx == values) 1054 valuesx = (Expressions *)values->copy(); 1055 keysx->remove(i - 1); 1056 valuesx->remove(i - 1); 1057 i -= 1; // redo the i'th iteration 1058 break; 1059 } 1060 } 1061 } 1062 1063 if (keysx != keys || valuesx != values) 1064 { 1065 AssocArrayLiteralExp *ae; 1066 ae = new AssocArrayLiteralExp(loc, keysx, valuesx); 1063 1067 ae->type = type; 1064 1068 return ae; 1065 1069 } 1066 1070 return this; 1071 1072 Lerr: 1073 if (keysx != keys) 1074 delete keysx; 1075 if (valuesx != values) 1076 delete values; 1077 return EXP_CANT_INTERPRET; 1067 1078 } 1068 1079 … … 1201 1212 } 1202 1213 } 1203 if (e1 != EXP_CANT_INTERPRET && e1->op == TOKvar) 1214 if (e1 == EXP_CANT_INTERPRET) 1215 return e1; 1216 if (e1->op == TOKvar) 1204 1217 { 1205 1218 VarExp *ve = (VarExp *)e1; … … 1460 1473 if (e1 == EXP_CANT_INTERPRET) 1461 1474 goto Lcant; 1462 if (e1->op == TOKstring || e1->op == TOKarrayliteral )1475 if (e1->op == TOKstring || e1->op == TOKarrayliteral || e1->op == TOKassocarrayliteral) 1463 1476 { 1464 1477 e = ArrayLength(type, e1); … … 1484 1497 goto Lcant; 1485 1498 1486 /* Set the $ variable 1487 */ 1488 e = ArrayLength(Type::tsize_t, e1); 1489 if (e == EXP_CANT_INTERPRET) 1490 goto Lcant; 1491 if (lengthVar) 1492 lengthVar->value = e; 1499 if (op == TOKstring || op == TOKarrayliteral) 1500 { 1501 /* Set the $ variable 1502 */ 1503 e = ArrayLength(Type::tsize_t, e1); 1504 if (e == EXP_CANT_INTERPRET) 1505 goto Lcant; 1506 if (lengthVar) 1507 lengthVar->value = e; 1508 } 1493 1509 1494 1510 e2 = this->e2->interpret(istate); trunk/rebuild/link.c
r511 r522 1 1 2 2 3 // Copyright (c) 1999-200 6by Digital Mars3 // Copyright (c) 1999-2007 by Digital Mars 4 4 // All Rights Reserved 5 5 // written by Walter Bright … … 131 131 return cline; 132 132 } 133 133 134 134 int runLINK() 135 135 { … … 159 159 else 160 160 { /* Generate exe file name from first sourcefile name, or object file 161 * name if that fails */161 * name if that fails */ 162 162 char *n; 163 163 if (global.cmodules && … … 171 171 n = (char *)global.params.objfiles->data[0]; 172 172 173 char *e;174 char *ex;175 176 n = FileName::name(n);177 e = FileName::ext(n);178 if (e)179 {180 e--; // back up over '.'173 char *e; 174 char *ex; 175 176 n = FileName::name(n); 177 e = FileName::ext(n); 178 if (e) 179 { 180 e--; // back up over '.' 181 181 out = string(n).substr(0, e - n); 182 }183 else182 } 183 else 184 184 { 185 185 out = "a.out"; … … 259 259 return 0; 260 260 } 261 261 262 262 void runClean() 263 263 { trunk/rebuild/mars.c
r512 r522 50 50 51 51 void getenv_setargv(const char *envvar, int *pargc, char** *pargv); 52 void string_setargv(const char *, int *, char***); 52 53 53 54 Global global; … … 65 66 copyright = "Copyright (c) 1999-2007 by Digital Mars and Gregor Richards"; 66 67 written = "written by Walter Bright and Gregor Richards"; 67 version = "version 0.62 (based on DMD 1.01 2)";68 version = "version 0.62 (based on DMD 1.013)"; 68 69 global.structalign = 8; 69 70 cmodules = NULL; … … 428 429 } 429 430 430 getenv_setargv("DFLAGS", &argc, &argv); 431 // get any arguments from $REBUILD_FLAGS... 432 getenv_setargv("REBUILD_FLAGS", &argc, &argv); 433 434 // and from $BUILD_FLAGS 435 getenv_setargv("BUILD_FLAGS", &argc, &argv); 436 437 // and from the configuration file 438 if (masterConfig.find("") != masterConfig.end() && 439 masterConfig[""].find("flags") != masterConfig[""].end()) { 440 string_setargv(masterConfig[""]["flags"].c_str(), &argc, &argv); 441 } 431 442 432 443 #if 0 … … 1596 1607 1597 1608 1609 void string_setargv(const char *, int *, char***); 1598 1610 1599 1611 /*********************************** … … 1606 1618 { 1607 1619 char *env; 1620 env = getenv(envvar); 1621 if (!env) 1622 return; 1623 string_setargv(env, pargc, pargv); 1624 } 1625 1626 1627 /*********************************** 1628 * Parse and append contents of a string 1629 * to argc and argv[]. 1630 * The string is separated into arguments, processing \ and ". 1631 */ 1632 1633 void string_setargv(const char *string, int *pargc, char** *pargv) 1634 { 1635 char *env; 1608 1636 char *p; 1609 1637 Array *argv; … … 1616 1644 int j; 1617 1645 1618 env = getenv(envvar); 1619 if (!env) 1620 return; 1621 1622 env = mem.strdup(env); // create our own writable copy 1646 env = mem.strdup(string); // create our own writable copy 1623 1647 1624 1648 argc = *pargc; trunk/rebuild/mtype.c
r459 r522 1676 1676 } 1677 1677 1678 Expression *semanticLength(Scope *sc, TupleDeclaration *s, Expression *exp) 1679 { 1680 ScopeDsymbol *sym = new ArrayScopeSymbol(s); 1681 sym->parent = sc->scopesym; 1682 sc = sc->push(sym); 1683 1684 exp = exp->semantic(sc); 1685 1686 sc->pop(); 1687 return exp; 1688 } 1689 1678 1690 void TypeSArray::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps) 1679 1691 { … … 1744 1756 { 1745 1757 //printf("TypeSArray::semantic() %s\n", toChars()); 1758 1759 Type *t; 1760 Expression *e; 1761 Dsymbol *s; 1762 next->resolve(loc, sc, &e, &t, &s); 1763 if (dim && s && s->isTupleDeclaration()) 1764 { TupleDeclaration *sd = s->isTupleDeclaration(); 1765 1766 dim = semanticLength(sc, sd, dim); 1767 dim = dim->optimize(WANTvalue | WANTinterpret); 1768 uinteger_t d = dim->toUInteger(); 1769 1770 if (d >= sd->objects->dim) 1771 { error(loc, "tuple index %ju exceeds %u", d, sd->objects->dim); 1772 return Type::terror; 1773 } 1774 Object *o = (Object *)sd->objects->data[(size_t)d]; 1775 if (o->dyncast() != DYNCAST_TYPE) 1776 { error(loc, "%s is not a type", toChars()); 1777 return Type::terror; 1778 } 1779 t = (Type *)o; 1780 return t; 1781 } 1782 1746 1783 next = next->semantic(loc,sc); 1747 1784 Type *tbn = next->toBasetype(); … … 1761 1798 goto Loverflow; 1762 1799 1763 if (tbn->ty == Tbit && (d2 + 31) < d2) 1764 goto Loverflow; 1765 else if (tbn->isintegral() || 1800 if (tbn->isintegral() || 1766 1801 tbn->isfloating() || 1767 1802 tbn->ty == Tpointer || … … 2203 2238 FuncDeclaration *fd; 2204 2239 Expressions *arguments; 2205 char aakeys[7+3*sizeof(int)+1];2206 2240 int size = key->size(e->loc); 2207 2241 2208 2242 assert(size); 2209 #if 0 2210 if (size == 1 || size == 2 || size == 4 || size == 8) 2211 { 2212 sprintf(aakeys, "_aaKeys%d", size); 2213 size = 0; 2214 } 2215 else 2216 #endif 2217 strcpy(aakeys, "_aaKeys"); 2218 fd = FuncDeclaration::genCfunc(Type::tindex, aakeys); 2243 fd = FuncDeclaration::genCfunc(Type::tindex, "_aaKeys"); 2219 2244 ec = new VarExp(0, fd); 2220 2245 arguments = new Expressions(); 2221 2246 arguments->push(e); 2222 if (size) 2223 arguments->push(new IntegerExp(0, size, Type::tsize_t)); 2247 arguments->push(new IntegerExp(0, size, Type::tsize_t)); 2224 2248 e = new CallExp(e->loc, ec, arguments); 2225 2249 e->type = index->arrayOf(); trunk/rebuild/opover.c
r459 r522 1 1 2 2 // Compiler implementation of the D programming language 3 // Copyright (c) 1999-200 6by Digital Mars3 // Copyright (c) 1999-2007 by Digital Mars 4 4 // All Rights Reserved 5 5 // written by Walter Bright … … 27 27 #endif 28 28 29 #include "port.h"29 //#include "port.h" 30 30 #include "mtype.h" 31 31 #include "init.h" trunk/rebuild/optimize.c
r461 r522 265 265 //printf("CastExp::optimize(result = %d) %s\n", result, toChars()); 266 266 //printf("from %s to %s\n", type->toChars(), to->toChars()); 267 //printf("from %s\n", type->toChars()); 267 268 //printf("type = %p\n", type); 268 269 assert(type); 269 270 e1 = e1->optimize(result); 270 enum TOK op1 = e1->op; 271 272 e1 = e1->optimize(result); 273 if (result & WANTinterpret) 274 e1 = fromConstInitializer(e1); 275 271 276 if ((e1->op == TOKstring || e1->op == TOKarrayliteral) && 272 277 (type->ty == Tpointer || type->ty == Tarray) && … … 277 282 return e1; 278 283 } 284 /* The first test here is to prevent infinite loops 285 */ 286 if (op1 != TOKarrayliteral && e1->op == TOKarrayliteral) 287 return e1->castTo(NULL, to); 279 288 if (e1->op == TOKnull && 280 289 (type->ty == Tpointer || type->ty == Tclass)) … … 520 529 e1 = e1->optimize(WANTvalue | (result & WANTinterpret)); 521 530 e = this; 522 if (e1->op == TOKstring || e1->op == TOKarrayliteral )531 if (e1->op == TOKstring || e1->op == TOKarrayliteral || e1->op == TOKassocarrayliteral) 523 532 { 524 533 e = ArrayLength(type, e1); trunk/rebuild/parse.c
r459 r522 192 192 193 193 case TOKinvariant: 194 #if 1 195 s = parseInvariant(); 196 #else 194 197 if (peek(&token)->value == TOKlcurly) 195 198 s = parseInvariant(); … … 199 202 goto Lstc; 200 203 } 204 #endif 201 205 break; 202 206 … … 268 272 case TOKsynchronized: stc |= STCsynchronized; goto Lstc; 269 273 case TOKdeprecated: stc |= STCdeprecated; goto Lstc; 270 case TOKinvariant: stc |= STCinvariant; goto Lstc;274 //case TOKinvariant: stc |= STCinvariant; goto Lstc; 271 275 default: 272 276 break; … … 2002 2006 } 2003 2007 v->storage_class = storage_class; 2004 a->push(v); 2008 if (link == linkage) 2009 a->push(v); 2010 else 2011 { 2012 Array *ax = new Array(); 2013 ax->push(v); 2014 Dsymbol *s = new LinkDeclaration(link, ax); 2015 a->push(s); 2016 } 2005 2017 switch (token.value) 2006 2018 { case TOKsemicolon: … … 2062 2074 v = new VarDeclaration(loc, t, ident, init); 2063 2075 v->storage_class = storage_class; 2064 a->push(v); 2076 if (link == linkage) 2077 a->push(v); 2078 else 2079 { 2080 Array *ax = new Array(); 2081 ax->push(v); 2082 Dsymbol *s = new LinkDeclaration(link, ax); 2083 a->push(s); 2084 } 2065 2085 switch (token.value) 2066 2086 { case TOKsemicolon: … … 2328 2348 case TOKvoid: 2329 2349 t = peek(&token); 2330 if (t->value == TOKsemicolon )2350 if (t->value == TOKsemicolon || t->value == TOKcomma) 2331 2351 { 2332 2352 nextToken(); … … 3962 3982 3963 3983 case TOKlbracket: 3964 { Expressions *elements = parseArguments(); 3965 3966 e = new ArrayLiteralExp(loc, elements); 3984 { /* Parse array literals and associative array literals: 3985 * [ value, value, value ... ] 3986 * [ key:value, key:value, key:value ... ] 3987 */ 3988 Expressions *values = new Expressions(); 3989 Expressions *keys = NULL; 3990 3991 nextToken(); 3992 if (token.value != TOKrbracket) 3993 { 3994 while (1) 3995 { 3996 Expression *e = parseAssignExp(); 3997 if (token.value == TOKcolon && (keys || values->dim == 0)) 3998 { nextToken(); 3999 if (!keys) 4000 keys = new Expressions(); 4001 keys->push(e); 4002 e = parseAssignExp(); 4003 } 4004 else if (keys) 4005 { error("'key:value' expected for associative array literal"); 4006 delete keys; 4007 keys = NULL; 4008 } 4009 values->push(e); 4010 if (token.value == TOKrbracket) 4011 break; 4012 check(TOKcomma); 4013 } 4014 } 4015 check(TOKrbracket); 4016 4017 if (keys) 4018 e = new AssocArrayLiteralExp(loc, keys, values); 4019 else 4020 e = new ArrayLiteralExp(loc, values); 3967 4021 break; 3968 4022 } trunk/rebuild/port.h
r272 r522 35 35 static double dbl_min; 36 36 37 static int isnan(double); 38 static int isfinite(double); 39 static int isinfinity(double); 40 static int signbit(double); 37 #if __GNUC__ 38 // These conflict with macros in math.h, should rename them 39 #undef isnan 40 #undef isfinite 41 #undef isinfinity 42 #undef signbit 43 #endif 44 static int isNan(double); 45 static int isFinite(double); 46 static int isInfinity(double); 47 static int Signbit(double); 41 48 42 49 static double floor(double); trunk/rebuild/statement.c
r504 r522 2479 2479 fd->nrvo_can = 0; 2480 2480 } 2481 else 2482 fd->nrvo_can = 0; 2481 2483 2482 2484 if (fd->returnLabel && tbret->ty != Tvoid) trunk/sss/build.d
r475 r522 85 85 writefln("Creating imports for %s", target); 86 86 87 // do the predigen 88 if ("predigen" in settings) { 89 dsssScriptedStep(conf, settings["predigen"]); 90 } 91 87 92 // this is a library, so make .di files 88 93 char[][] srcFiles = targetToFiles(build, conf); … … 122 127 } 123 128 } 129 } 130 131 // do the postdigen 132 if ("postdigen" in settings) { 133 dsssScriptedStep(conf, settings["postdigen"]); 124 134 } 125 135
