dsource.org

Open Source Development for
the D Programming Language

Navigation

← Previous Changeset
Next Changeset →

Changeset 800

Timestamp:

09/06/07 12:06:07 (1 year ago)

Author:

Gregor

Message:

rebuild/*: A few improvements (I hope).

sss/build.d: Fixed multi-compiler stuff.

Files:

trunk/rebuild/attrib.c (modified) (2 diffs)
trunk/rebuild/parse.c (modified) (58 diffs)
trunk/rebuild/statement.c (modified) (4 diffs)
trunk/sss/build.d (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/rebuild/attrib.c

r785	r800
833	833
834	834	e = e->semantic(sc);
	835	e = e->optimize(WANTvalue \| WANTinterpret);
835	836	if (e->op == TOKstring)
836	837	{
…	…
854	855
855	856	e = e->semantic(sc);
	857	e = e->optimize(WANTvalue \| WANTinterpret);
856	858	if (e->op == TOKstring)
857	859	{

trunk/rebuild/parse.c

r798	r800
72	72	nextToken();
73	73	if (token.value != TOKidentifier)
74		{ // error("Identifier expected following module");
	74	{ error("Identifier expected following module");
75	75	goto Lerr;
76	76	}
…	…
88	88	nextToken();
89	89	if (token.value != TOKidentifier)
90		{ // error("Identifier expected following package");
	90	{ error("Identifier expected following package");
91	91	goto Lerr;
92	92	}
…	…
96	96	md = new ModuleDeclaration(a, id);
97	97
98		/* if (token.value != TOKsemicolon)
99		error("';' expected following module declaration instead of %s", token.toChars()); */
	98	if (token.value != TOKsemicolon)
	99	error("';' expected following module declaration instead of %s", token.toChars());
100	100	nextToken();
101	101	addComment(mod, comment);
…	…
105	105	decldefs = parseDeclDefs(0);
106	106	if (token.value != TOKeof)
107		{ // error("unrecognized declaration");
	107	{ error("unrecognized declaration");
108	108	goto Lerr;
109	109	}
…	…
333	333	continue;
334	334	}
335		/* else
336		error("Identifier expected following comma"); * */
	335	else
	336	error("Identifier expected following comma");
337	337	}
338		/* else
339		error("semicolon expected following auto declaration, not '%s'", token.toChars()); */
	338	else
	339	error("semicolon expected following auto declaration, not '%s'", token.toChars());
340	340	break;
341	341	}
…	…
383	383	n = (unsigned)token.uns64value;
384	384	else
385		{ // error("integer expected, not %s", token.toChars());
	385	{ error("integer expected, not %s", token.toChars());
386	386	n = 1;
387	387	}
…	…
404	404	check(TOKlparen);
405	405	if (token.value != TOKidentifier)
406		{ // error("pragma(identifier expected");
	406	{ error("pragma(identifier expected");
407	407	goto Lerror;
408	408	}
…	…
432	432	s = new DebugSymbol(loc, (unsigned)token.uns64value);
433	433	else
434		{ // error("identifier or integer expected, not %s", token.toChars());
	434	{ error("identifier or integer expected, not %s", token.toChars());
435	435	s = NULL;
436	436	}
437	437	nextToken();
438		/* if (token.value != TOKsemicolon)
439		error("semicolon expected"); */
	438	if (token.value != TOKsemicolon)
	439	error("semicolon expected");
440	440	nextToken();
441	441	break;
…	…
455	455	s = new VersionSymbol(loc, (unsigned)token.uns64value);
456	456	else
457		{ // error("identifier or integer expected, not %s", token.toChars());
	457	{ error("identifier or integer expected, not %s", token.toChars());
458	458	s = NULL;
459	459	}
460	460	nextToken();
461		/* if (token.value != TOKsemicolon)
462		error("semicolon expected"); */
	461	if (token.value != TOKsemicolon)
	462	error("semicolon expected");
463	463	nextToken();
464	464	break;
…	…
512	512	{
513	513	case TOKsemicolon:
514		// error("declaration expected following attribute, not ';'");
	514	error("declaration expected following attribute, not ';'");
515	515	nextToken();
516	516	break;
…	…
521	521	if (token.value != TOKrcurly)
522	522	{ /* { */
523		// error("matching '}' expected, not %s", token.toChars());
	523	error("matching '}' expected, not %s", token.toChars());
524	524	}
525	525	else
…	…
606	606	else
607	607	{
608		// error("valid linkage identifiers are D, C, C++, Pascal, Windows, System");
	608	error("valid linkage identifiers are D, C, C++, Pascal, Windows, System");
609	609	link = LINKd;
610	610	}
…	…
636	636	else if (token.value == TOKint32v)
637	637	level = (unsigned)token.uns64value;
638		/* else
639		error("identifier or integer expected, not %s", token.toChars()); */
	638	else
	639	error("identifier or integer expected, not %s", token.toChars());
640	640	nextToken();
641	641	check(TOKrparen);
…	…
665	665	else if (token.value == TOKint32v)
666	666	level = (unsigned)token.uns64value;
667		/* else
668		error("identifier or integer expected, not %s", token.toChars()); */
	667	else
	668	error("identifier or integer expected, not %s", token.toChars());
669	669	nextToken();
670	670	check(TOKrparen);
671	671
672	672	}
673		/* else
674		error("(condition) expected following version"); */
	673	else
	674	error("(condition) expected following version");
675	675	c = new VersionCondition(mod, level, id);
676	676	return c;
…	…
700	700	}
701	701	else
702		{ // error("(expression) expected following static if");
	702	{ error("(expression) expected following static if");
703	703	exp = NULL;
704	704	}
…	…
870	870	nextToken();
871	871	arguments = parseParameters(&varargs);
872		/* if (varargs)
873		error("... not allowed in delete function parameter list"); */
	872	if (varargs)
	873	error("... not allowed in delete function parameter list");
874	874	f = new DeleteDeclaration(loc, 0, arguments);
875	875	parseContracts(f);
…	…
1064	1064	}
1065	1065	else
1066		{ // error("enum member expected");
	1066	{ error("enum member expected");
1067	1067	nextToken();
1068	1068	}
…	…
1070	1070	nextToken();
1071	1071	}
1072		/* else
1073		error("enum declaration is invalid"); */
	1072	else
	1073	error("enum declaration is invalid");
1074	1074
1075	1075	return e;
…	…
1116	1116	baseclasses = parseBaseClasses();
1117	1117
1118		/* if (token.value != TOKlcurly)
1119		error("members expected"); */
	1118	if (token.value != TOKlcurly)
	1119	error("members expected");
1120	1120	}
1121	1121
…	…
1153	1153	nextToken();
1154	1154	Array *decl = parseDeclDefs(0);
1155		/* if (token.value != TOKrcurly)
1156		error("} expected following member declarations in aggregate"); */
	1155	if (token.value != TOKrcurly)
	1156	error("} expected following member declarations in aggregate");
1157	1157	nextToken();
1158	1158	if (anon)
…	…
1167	1167	else
1168	1168	{
1169		// error("{ } expected following aggregate declaration");
	1169	error("{ } expected following aggregate declaration");
1170	1170	a = new StructDeclaration(loc, NULL);
1171	1171	}
…	…
1238	1238	nextToken();
1239	1239	if (token.value != TOKidentifier)
1240		{ // error("TemplateIdentifier expected following template");
	1240	{ error("TemplateIdentifier expected following template");
1241	1241	goto Lerr;
1242	1242	}
…	…
1248	1248
1249	1249	if (token.value != TOKlcurly)
1250		{ // error("members of template declaration expected");
	1250	{ error("members of template declaration expected");
1251	1251	goto Lerr;
1252	1252	}
…	…
1256	1256	decldefs = parseDeclDefs(0);
1257	1257	if (token.value != TOKrcurly)
1258		{ // error("template member expected");
	1258	{ error("template member expected");
1259	1259	goto Lerr;
1260	1260	}
…	…
1278	1278
1279	1279	if (token.value != TOKlparen)
1280		{ // error("parenthesized TemplateParameterList expected following TemplateIdentifier");
	1280	{ error("parenthesized TemplateParameterList expected following TemplateIdentifier");
1281	1281	goto Lerr;
1282	1282	}
…	…
1306	1306	nextToken();
1307	1307	if (token.value != TOKidentifier)
1308		{ // error("Identifier expected for template parameter");
	1308	{ error("Identifier expected for template parameter");
1309	1309	goto Lerr;
1310	1310	}
…	…
1327	1327	{ // TypeParameter
1328	1328	if (token.value != TOKidentifier)
1329		{ // error("Identifier expected for template parameter");
	1329	{ error("Identifier expected for template parameter");
1330	1330	goto Lerr;
1331	1331	}
…	…
1346	1346	else if (token.value == TOKidentifier && t->value == TOKdotdotdot)
1347	1347	{ // ident...
1348		/* if (isvariadic)
1349		error("variadic template parameter must be last"); */
	1348	if (isvariadic)
	1349	error("variadic template parameter must be last");
1350	1350	isvariadic = 1;
1351	1351	tp_ident = token.ident;
…	…
1359	1359	if (!tp_ident)
1360	1360	{
1361		// error("no identifier for template value parameter");
	1361	error("no identifier for template value parameter");
1362	1362	goto Lerr;
1363	1363	}
…	…
1425	1425	if (token.value != TOKidentifier)
1426	1426	{
1427		// error("identifier expected, not %s", token.toChars());
	1427	error("identifier expected, not %s", token.toChars());
1428	1428	goto Lerr;
1429	1429	}
…	…
1455	1455	nextToken();
1456	1456	if (token.value != TOKidentifier)
1457		{ // error("identifier expected following '.' instead of '%s'", token.toChars());
	1457	{ error("identifier expected following '.' instead of '%s'", token.toChars());
1458	1458	break;
1459	1459	}
…	…
1472	1472
1473	1473	tm = new TemplateMixin(loc, id, tqual, idents, tiargs);
1474		/* if (token.value != TOKsemicolon)
1475		error("';' expected after mixin"); */
	1474	if (token.value != TOKsemicolon)
	1475	error("';' expected after mixin");
1476	1476	nextToken();
1477	1477
…	…
1494	1494	//printf("Parser::parseTemplateArgumentList()\n");
1495	1495	if (token.value != TOKlparen)
1496		{ // error("!(TemplateArgumentList) expected following TemplateIdentifier");
	1496	{ error("!(TemplateArgumentList) expected following TemplateIdentifier");
1497	1497	return new Objects();
1498	1498	}
…	…
1548	1548	nextToken();
1549	1549	if (token.value != TOKidentifier)
1550		{ // error("Identifier expected following import");
	1550	{ error("Identifier expected following import");
1551	1551	break;
1552	1552	}
…	…
1568	1568	nextToken();
1569	1569	if (token.value != TOKidentifier)
1570		{ // error("Identifier expected following package");
	1570	{ error("Identifier expected following package");
1571	1571	break;
1572	1572	}
…	…
1590	1590	nextToken();
1591	1591	if (token.value != TOKidentifier)
1592		{ // error("Identifier expected following :");
	1592	{ error("Identifier expected following :");
1593	1593	break;
1594	1594	}
…	…
1599	1599	nextToken();
1600	1600	if (token.value != TOKidentifier)
1601		{ // error("Identifier expected following %s=", alias->toChars());
	1601	{ error("Identifier expected following %s=", alias->toChars());
1602	1602	break;
1603	1603	}
…	…
1621	1621	else
1622	1622	{
1623		// error("';' expected");
	1623	error("';' expected");
1624	1624	nextToken();
1625	1625	}
…	…
1685	1685	{ nextToken();
1686	1686	if (token.value != TOKidentifier)
1687		{ // error("identifier expected following '.' instead of '%s'", token.toChars());
	1687	{ error("identifier expected following '.' instead of '%s'", token.toChars());
1688	1688	break;
1689	1689	}
…	…
1737	1737
1738	1738	default:
1739		// error("basic type expected, not %s", token.toChars());
	1739	error("basic type expected, not %s", token.toChars());
1740	1740	t = Type::tint32;
1741	1741	break;
…	…
2028	2028	if (!(token.value == TOKidentifier && peek(&token)->value == TOKassign))
2029	2029	{
2030		// error("Identifier expected following comma");
	2030	error("Identifier expected following comma");
2031	2031	}
2032	2032	else
2033	2033	continue;
2034	2034	}
2035		/* else
2036		error("semicolon expected following auto declaration, not '%s'", token.toChars()); */
	2035	else
	2036	error("semicolon expected following auto declaration, not '%s'", token.toChars());
2037	2037	return a;
2038	2038	}
…	…
2065	2065	error("multiple declarations must have the same type, not %s and %s",
2066	2066	tfirst->toChars(), t->toChars()); */
2067		/* if (!ident)
2068		error("no identifier for declarator %s", t->toChars()); */
	2067	if (!ident)
	2068	error("no identifier for declarator %s", t->toChars());
2069	2069
2070	2070	if (tok == TOKtypedef \|\| tok == TOKalias)
…	…
2107	2107
2108	2108	default:
2109		// error("semicolon expected to close %s declaration", Token::toChars(tok));
	2109	error("semicolon expected to close %s declaration", Token::toChars(tok));
2110	2110	break;
2111	2111	}
…	…
2175	2175
2176	2176	default:
2177		// error("semicolon expected, not '%s'", token.toChars());
	2177	error("semicolon expected, not '%s'", token.toChars());
2178	2178	break;
2179	2179	}
…	…
2200	2200	{
2201	2201	case TOKlcurly:
2202		/* if (f->frequire \|\| f->fensure)
2203		error("missing body { ... } after in or out"); */
	2202	if (f->frequire \|\| f->fensure)
	2203	error("missing body { ... } after in or out");
2204	2204	f->fbody = parseStatement(PSsemi);
2205	2205	f->endloc = endloc;
…	…
2213	2213
2214	2214	case TOKsemicolon:
2215		/* if (f->frequire \|\| f->fensure)
2216		error("missing body { ... } after in or out"); */
	2215	if (f->frequire \|\| f->fensure)
	2216	error("missing body { ... } after in or out");
2217	2217	nextToken();
2218	2218	break;
…	…
2258	2258	{
2259	2259	check(TOKlparen);
2260		/* if (token.value != TOKidentifier)
2261		error("(identifier) following 'out' expected, not %s", token.toChars()); */
	2260	if (token.value != TOKidentifier)
	2261	error("(identifier) following 'out' expected, not %s", token.toChars());
2262	2262	f->outId = token.ident;
2263	2263	nextToken();
…	…
2270	2270
2271	2271	default:
2272		// error("semicolon expected following function declaration");
	2272	error("semicolon expected following function declaration");
2273	2273	break;
2274	2274	}
…	…
2459	2459	//printf("parseStatement()\n");
2460	2460
2461		/* if (flags & PScurly && token.value != TOKlcurly)
2462		error("statement expected to be { }, not %s", token.toChars()); */
	2461	if (flags & PScurly && token.value != TOKlcurly)
	2462	error("statement expected to be { }, not %s", token.toChars());
2463	2463
2464	2464	switch (token.value)
…	…
2755	2755	}
2756	2756	at = parseType(&ai);
2757		/* if (!ai)
2758		error("no identifier for declarator %s", at->toChars()); */
	2757	if (!ai)
	2758	error("no identifier for declarator %s", at->toChars());
2759	2759	Larg:
2760	2760	a = new Argument(storageClass, at, ai, NULL);
…	…
3239	3239	case TOKeof:
3240	3240	/* { */
3241		// error("matching '}' expected, not end of file");
	3241	error("matching '}' expected, not end of file");
3242	3242	break;
3243	3243
…	…
3284	3284	void Parser::check(Loc loc, enum TOK value)
3285	3285	{
3286		/* if (token.value != value)
3287		error(loc, "found '%s' when expecting '%s'", token.toChars(), Token::toChars(value)); */
	3286	if (token.value != value)
	3287	error(loc, "found '%s' when expecting '%s'", token.toChars(), Token::toChars(value));
3288	3288	nextToken();
3289	3289	}
…	…
3291	3291	void Parser::check(enum TOK value, char *string)
3292	3292	{
3293		/* if (token.value != value)
	3293	if (token.value != value)
3294	3294	error("found '%s' when expecting '%s' following '%s'",
3295		token.toChars(), Token::toChars(value), string); */
	3295	token.toChars(), Token::toChars(value), string);
3296	3296	nextToken();
3297	3297	}
…	…
3984	3984	check(TOKdot, t->toChars());
3985	3985	if (token.value != TOKidentifier)
3986		{ // error("found '%s' when expecting identifier following '%s.'", token.toChars(), t->toChars());
	3986	{ error("found '%s' when expecting identifier following '%s.'", token.toChars(), t->toChars());
3987	3987	goto Lerr;
3988	3988	}
…	…
4261	4261	continue;
4262	4262	}
4263		/* else
4264		error("identifier expected following '.', not '%s'", token.toChars()); */
	4263	else
	4264	error("identifier expected following '.', not '%s'", token.toChars());
4265	4265	break;
4266	4266
…	…
4483	4483	nextToken();
4484	4484	if (token.value != TOKidentifier)
4485		{ // error("Identifier expected following (type).");
	4485	{ error("Identifier expected following (type).");
4486	4486	return NULL;
4487	4487	}
…	…
4971	4971
4972	4972	if (token.value != TOKlcurly)
4973		{ // error("{ members } expected for anonymous class");
	4973	{ error("{ members } expected for anonymous class");
4974	4974	cd->members = NULL;
4975	4975	}
…	…
4978	4978	nextToken();
4979	4979	Array *decl = parseDeclDefs(0);
4980		/* if (token.value != TOKrcurly)
4981		error("class member expected"); */
	4980	if (token.value != TOKrcurly)
	4981	error("class member expected");
4982	4982	nextToken();
4983	4983	cd->members = decl;

trunk/rebuild/statement.c

r785	r800
2030	2030
2031	2031	e = e->semantic(sc);
	2032	e = e->optimize(WANTvalue \| WANTinterpret);
2032	2033	if (e->op == TOKstring)
2033	2034	{
…	…
2035	2036	linkLibrary((char *) se->string);
2036	2037	}
2037		/* else
2038		error("string expected for link, not '%s'", e->toChars()); */
	2038	else
	2039	error("string expected for link, not '%s'", e->toChars());
2039	2040	}
2040	2041	}
…	…
2050	2051
2051	2052	e = e->semantic(sc);
	2053	e = e->optimize(WANTvalue \| WANTinterpret);
2052	2054	if (e->op == TOKstring)
2053	2055	{
…	…
2059	2061	toadd = e->toChars();
2060	2062	}
2061		/* else
2062		error("string or identifier expected for export_version, not '%s'", e->toChars()); */
	2063	else
	2064	error("string or identifier expected for export_version, not '%s'", e->toChars());
2063	2065
2064	2066	/* add this version flag to our own idea of versions, as

trunk/sss/build.d

r799	r800
113	113	debugPrefix = "debug-";
114	114
115		// generate the pragmas
	115	/* generate the pragmas (FIXME: this should be done in a
	116	* nicer way) */
116	117	char[] defaultLibName = libraryName(build);
117	118	if (defaultLibName == target) {
118	119	std.file.write(ifile, std.file.read(file) ~ `
119		~~import sss.platform;~~
120	120	version (build) {
121	121	debug {
122		pragma(link, "` ~ debugPrefix ~ `D" ~ DSSS_PLATFORM ~ "` ~ target[2..$] ~ `");
	122	version (GNU) {
	123	pragma(link, "` ~ debugPrefix ~ `DG` ~ target[2..$] ~ `");
	124	} else version (DigitalMars) {
	125	pragma(link, "` ~ debugPrefix ~ `DD` ~ target[2..$] ~ `");
	126	} else {
	127	pragma(link, "` ~ debugPrefix ~ `DO` ~ target[2..$] ~ `");
	128	}
123	129	} else {
124		pragma(link, "D" ~ DSSS_PLATFORM ~ "` ~ target[2..$] ~ `");
	130	version (GNU) {
	131	pragma(link, "DG` ~ target[2..$] ~ `");
	132	} else version (DigitalMars) {
	133	pragma(link, "DD` ~ target[2..$] ~ `");
	134	} else {
	135	pragma(link, "DO` ~ target[2..$] ~ `");
	136	}
125	137	}
126	138	}

Download in other formats:

© Copyright 2004-2008 - The Sankaty Group, Inc. All rights reserved.

Make a Donation

Privacy Statement Terms of Service