projects/ldc: dmd2/statement.c comparison

comparison dmd2/statement.c @ 1452:638d16625da2

LDC 2 compiles again.

author	Robert Clipsham <robert@octarineparrot.com>
date	Sat, 30 May 2009 17:23:32 +0100
parents	5fa3e0ea06e9
children	54b3c1394d62

comparison

equal deleted inserted replaced

-:42bd767ec5a4
+:638d16625da2
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2008 by Digital Mars
+// Copyright (c) 1999-2009 by Digital Mars
 // All Rights Reserved
 // written by Walter Bright
 // http://www.digitalmars.com
 // License for redistribution is by either the Artistic License
 // in artistic.txt, or the GNU General Public License in gnu.txt.
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
-#include "mem.h"
+#include "rmem.h"
 #include "statement.h"
 #include "expression.h"
 #include "cond.h"
 #include "init.h"
 #include "aggregate.h"
 #include "id.h"
 #include "hdrgen.h"
 #include "parse.h"
 #include "template.h"
+#include "attrib.h"
 /******************************** Statement ***************************/
 Statement::Statement(Loc loc)
 : loc(loc)
 va_start(ap, format);
 ::verror(loc, format, ap);
 va_end( ap );
 }
+void Statement::warning(const char *format, ...)
+{
+if (global.params.warnings && !global.gag)
+{
+	va_list ap;
+	va_start(ap, format);
+	::vwarning(loc, format, ap);
+	va_end( ap );
+}
+}
 int Statement::hasBreak()
 {
 //printf("Statement::hasBreak()\n");
 return FALSE;
 }
 {
 printf("Statement::blockExit(%p)\n", this);
 printf("%s\n", toChars());
 assert(0);
 return BEany;
-}
-// TRUE if statement may fall off the end without a throw or return
-int Statement::fallOffEnd()
-{
-return TRUE;
 }
 // TRUE if statement 'comes from' somewhere else, like a goto
 int Statement::comeFrom()
 	    result |= BEthrow;
 }
 return result;
 }
-int ExpStatement::fallOffEnd()
-{
-if (exp)
-{
-	if (exp->op == TOKassert)
-	{   AssertExp *a = (AssertExp *)exp;
-	    if (a->e1->isBool(FALSE))	// if it's an assert(0)
-		return FALSE;
-	}
-	else if (exp->op == TOKhalt)
-	    return FALSE;
-}
-return TRUE;
-}
 /******************************** CompileStatement ***************************/
 CompileStatement::CompileStatement(Loc loc, Expression *exp)
 : Statement(loc)
 	{
 //printf("result = x%x\n", result);
 //printf("%s\n", s->toChars());
 	    if (!(result & BEfallthru) && !s->comeFrom())
 	    {
-		if (global.params.warnings)
+		s->warning("statement is not reachable");
-		{   fprintf(stdmsg, "warning - ");
-		    s->error("statement is not reachable");
-		}
 	    }
 	    result &= ~BEfallthru;
 	    result |= s->blockExit();
 	}
 }
 return result;
-}
-int CompoundStatement::fallOffEnd()
-{   int falloff = TRUE;
-//printf("CompoundStatement::fallOffEnd() %s\n", toChars());
-for (int i = 0; i < statements->dim; i++)
-{	Statement *s = (Statement *)statements->data[i];
-	if (!s)
-	    continue;
-#if 0
-	if (!falloff && global.params.warnings && !s->comeFrom())
-	{
-	    warning("%s: statement is not reachable", s->loc.toChars());
-	}
-#endif
-	falloff = s->fallOffEnd();
-}
-return falloff;
 }
 int CompoundStatement::comeFrom()
 {   int comefrom = FALSE;
 }
 return comefrom;
 }
-/**************************** UnrolledLoopStatement ***************************/
+/******************************** CompoundDeclarationStatement ***************************/
-UnrolledLoopStatement::UnrolledLoopStatement(Loc loc, Statements *s)
+CompoundDeclarationStatement::CompoundDeclarationStatement(Loc loc, Statements *s)
-: Statement(loc)
+: CompoundStatement(loc, s)
 {
 statements = s;
-enclosinghandler = NULL;
+}
-}
+Statement *CompoundDeclarationStatement::syntaxCopy()
-Statement *UnrolledLoopStatement::syntaxCopy()
 {
 Statements *a = new Statements();
 a->setDim(statements->dim);
 for (size_t i = 0; i < statements->dim; i++)
 {	Statement *s = (Statement *)statements->data[i];
 	if (s)
 	    s = s->syntaxCopy();
 	a->data[i] = s;
 }
+CompoundDeclarationStatement *cs = new CompoundDeclarationStatement(loc, a);
+return cs;
+}
+void CompoundDeclarationStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
+{
+int nwritten = 0;
+for (int i = 0; i < statements->dim; i++)
+{	Statement *s = (Statement *) statements->data[i];
+	if (s)
+	{   DeclarationStatement *ds = s->isDeclarationStatement();
+	    assert(ds);
+	    DeclarationExp *de = (DeclarationExp *)ds->exp;
+	    assert(de->op == TOKdeclaration);
+	    Declaration *d = de->declaration->isDeclaration();
+	    assert(d);
+	    VarDeclaration *v = d->isVarDeclaration();
+	    if (v)
+	    {
+		/* This essentially copies the part of VarDeclaration::toCBuffer()
+		 * that does not print the type.
+		 * Should refactor this.
+		 */
+		if (nwritten)
+		{
+		    buf->writeByte(',');
+		    buf->writestring(v->ident->toChars());
+		}
+		else
+		{
+		    StorageClassDeclaration::stcToCBuffer(buf, v->storage_class);
+		    if (v->type)
+			v->type->toCBuffer(buf, v->ident, hgs);
+		    else
+			buf->writestring(v->ident->toChars());
+		}
+		if (v->init)
+		{   buf->writestring(" = ");
+#if DMDV2
+		    ExpInitializer *ie = v->init->isExpInitializer();
+		    if (ie && (ie->exp->op == TOKconstruct || ie->exp->op == TOKblit))
+			((AssignExp *)ie->exp)->e2->toCBuffer(buf, hgs);
+		    else
+#endif
+			v->init->toCBuffer(buf, hgs);
+		}
+	    }
+	    else
+		d->toCBuffer(buf, hgs);
+	    nwritten++;
+	}
+}
+buf->writeByte(';');
+if (!hgs->FLinit.init)
+buf->writenl();
+}
+/**************************** UnrolledLoopStatement ***************************/
+UnrolledLoopStatement::UnrolledLoopStatement(Loc loc, Statements *s)
+: Statement(loc)
+{
+statements = s;
+}
+Statement *UnrolledLoopStatement::syntaxCopy()
+{
+Statements *a = new Statements();
+a->setDim(statements->dim);
+for (size_t i = 0; i < statements->dim; i++)
+{	Statement *s = (Statement *)statements->data[i];
+	if (s)
+	    s = s->syntaxCopy();
+	a->data[i] = s;
+}
 UnrolledLoopStatement *cs = new UnrolledLoopStatement(loc, a);
 return cs;
 }
 Statement *UnrolledLoopStatement::semantic(Scope *sc)
 {
 //printf("UnrolledLoopStatement::semantic(this = %p, sc = %p)\n", this, sc);
-enclosinghandler = sc->tfOfTry;
 sc->noctor++;
 Scope *scd = sc->push();
 scd->sbreak = this;
 scd->scontinue = this;
 	}
 }
 return result;
 }
-int UnrolledLoopStatement::fallOffEnd()
-{
-//printf("UnrolledLoopStatement::fallOffEnd()\n");
-for (size_t i = 0; i < statements->dim; i++)
-{	Statement *s = (Statement *)statements->data[i];
-	if (s)
-	    s->fallOffEnd();
-}
-return TRUE;
-}
 int UnrolledLoopStatement::comeFrom()
 {   int comefrom = FALSE;
 //printf("UnrolledLoopStatement::comeFrom()\n");
 {
 //printf("ScopeStatement::blockExit(%p)\n", statement);
 return statement ? statement->blockExit() : BEfallthru;
 }
-int ScopeStatement::fallOffEnd()
-{
-return statement ? statement->fallOffEnd() : TRUE;
-}
 int ScopeStatement::comeFrom()
 {
 //printf("ScopeStatement::comeFrom()\n");
 return statement ? statement->comeFrom() : FALSE;
 WhileStatement::WhileStatement(Loc loc, Expression *c, Statement *b)
 : Statement(loc)
 {
 condition = c;
 body = b;
-enclosinghandler = NULL;
 }
 Statement *WhileStatement::syntaxCopy()
 {
 WhileStatement *s = new WhileStatement(loc, condition->syntaxCopy(), body ? body->syntaxCopy() : NULL);
 	Statement *si = new IfStatement(loc, condition, sw, NULL);
 	return si->semantic(sc);
 }
 #endif
-enclosinghandler = sc->tfOfTry;
 condition = condition->semantic(sc);
 condition = resolveProperties(sc, condition);
 condition = condition->optimize(WANTvalue);
 condition = condition->checkToBoolean();
 }
 result &= ~(BEbreak | BEcontinue);
 return result;
 }
-int WhileStatement::fallOffEnd()
-{
-if (body)
-	body->fallOffEnd();
-return TRUE;
-}
 int WhileStatement::comeFrom()
 {
 if (body)
 	return body->comeFrom();
 DoStatement::DoStatement(Loc loc, Statement *b, Expression *c)
 : Statement(loc)
 {
 body = b;
 condition = c;
-enclosinghandler = NULL;
 }
 Statement *DoStatement::syntaxCopy()
 {
 DoStatement *s = new DoStatement(loc, body ? body->syntaxCopy() : NULL, condition->syntaxCopy());
 }
 Statement *DoStatement::semantic(Scope *sc)
 {
-enclosinghandler = sc->tfOfTry;
 sc->noctor++;
 if (body)
 	body = body->semanticScope(sc, this, this);
 sc->noctor--;
 condition = condition->semantic(sc);
 }
 result &= ~(BEbreak | BEcontinue);
 return result;
 }
-int DoStatement::fallOffEnd()
-{
-if (body)
-	body->fallOffEnd();
-return TRUE;
-}
 int DoStatement::comeFrom()
 {
 if (body)
 	return body->comeFrom();
 {
 this->init = init;
 this->condition = condition;
 this->increment = increment;
 this->body = body;
-this->enclosinghandler = NULL;
 }
 Statement *ForStatement::syntaxCopy()
 {
 Statement *i = NULL;
 return s;
 }
 Statement *ForStatement::semantic(Scope *sc)
 {
-enclosinghandler = sc->tfOfTry;
 ScopeDsymbol *sym = new ScopeDsymbol();
 sym->parent = sc->scopesym;
 sc = sc->push(sym);
 if (init)
 	init = init->semantic(sc);
 	increment = resolveProperties(sc, increment);
 }
 sc->sbreak = this;
 sc->scontinue = this;
-body = body->semantic(sc);
+if (body)
+	body = body->semantic(sc);
 sc->noctor--;
 sc->pop();
 return this;
 }
 }
 else
 	result &= ~BEfallthru;	// the body must do the exiting
 if (body)
 {	int r = body->blockExit();
-	if (r & BEbreak)
+	if (r & (BEbreak | BEgoto))
 	    result |= BEfallthru;
-	result |= r & ~(BEbreak | BEcontinue);
+	result |= r & ~(BEfallthru | BEbreak | BEcontinue);
 }
 if (increment && increment->canThrow())
 	result |= BEthrow;
 return result;
 }
-int ForStatement::fallOffEnd()
-{
-if (body)
-	body->fallOffEnd();
-return TRUE;
-}
 int ForStatement::comeFrom()
 {
 //printf("ForStatement::comeFrom()\n");
 if (body)
 {
 buf->writestring("for (");
 if (init)
 {
 hgs->FLinit.init++;
-hgs->FLinit.decl = 0;
 init->toCBuffer(buf, hgs);
-if (hgs->FLinit.decl > 0)
-buf->writebyte(';');
-hgs->FLinit.decl = 0;
 hgs->FLinit.init--;
 }
 else
 buf->writebyte(';');
 if (condition)
 {
 this->op = op;
 this->arguments = arguments;
 this->aggr = aggr;
 this->body = body;
-this->enclosinghandler = NULL;
 this->key = NULL;
 this->value = NULL;
 this->func = NULL;
 TypeAArray *taa = NULL;
 Type *tn = NULL;
 Type *tnv = NULL;
-enclosinghandler = sc->tfOfTry;
 func = sc->func;
 if (func->fes)
 	func = func->fes->func;
 aggr = aggr->semantic(sc);
 {
 	error("invalid foreach aggregate %s", aggr->toChars());
 	return this;
 }
-inferApplyArgTypes(op, arguments, aggr);
+inferApplyArgTypes(op, arguments, aggr, sc->module);
 /* Check for inference errors
 */
 if (dim != arguments->dim)
 {
 	    if (dim == 2)
 	    {   // Declare key
 		if (arg->storageClass & (STCout | STCref | STClazy))
 		    error("no storage class for key %s", arg->ident->toChars());
 		TY keyty = arg->type->ty;
-if (global.params.is64bit)
+		if (keyty != Tint32 && keyty != Tuns32)
-{
+		{
-if (keyty != Tint32 && keyty != Tuns32 && keyty != Tint64 && keyty != Tuns64)
+		    if (global.params.is64bit)
-{
+		    {
-error("foreach: key type must be int, uint, long or ulong, not %s", key->type->toChars());
+			if (keyty != Tint64 && keyty != Tuns64)
-}
+			    error("foreach: key type must be int or uint, long or ulong, not %s", arg->type->toChars());
-}
+		    }
-else if (keyty != Tint32 && keyty != Tuns32)
+		    else
-{
+			error("foreach: key type must be int or uint, not %s", arg->type->toChars());
-error("foreach: key type must be int or uint, not %s", key->type->toChars());
+		}
-}
 		Initializer *ie = new ExpInitializer(0, new IntegerExp(k));
 		VarDeclaration *var = new VarDeclaration(loc, arg->type, arg->ident, ie);
 		var->storage_class |= STCmanifest;
 		DeclarationExp *de = new DeclarationExp(loc, var);
 		st->push(new ExpStatement(loc, de));
 		Argument *arg = (Argument *)arguments->data[i];
 		VarDeclaration *var;
 		var = new VarDeclaration(loc, arg->type, arg->ident, NULL);
 		var->storage_class |= STCforeach;
-		var->storage_class |= arg->storageClass & (STCin | STCout | STCref | STCconst | STCinvariant);
+		var->storage_class |= arg->storageClass & (STCin | STCout | STCref | STC_TYPECTOR);
 		if (dim == 2 && i == 0)
 		{   key = var;
 		    //var->storage_class |= STCfinal;
 		}
 		else
 		else
 		    error("foreach: %s is not an array of %s",
 			tab->toChars(), value->type->toChars());
 	    }
-if (key)
+	    if (key && key->type->ty != Tint32 && key->type->ty != Tuns32)
-{
+	    {
-if (global.params.is64bit)
+		if (global.params.is64bit)
-{
+		{
-if (key->type->ty != Tint32 && key->type->ty != Tuns32 && key->type->ty != Tint64 && key->type->ty != Tuns64)
+		    if (key->type->ty != Tint64 && key->type->ty != Tuns64)
-{
+			error("foreach: key type must be int or uint, long or ulong, not %s", key->type->toChars());
-error("foreach: key type must be int, uint, long or ulong, not %s", key->type->toChars());
+		}
-}
+		else
-}
+		    error("foreach: key type must be int or uint, not %s", key->type->toChars());
-else if (key->type->ty != Tint32 && key->type->ty != Tuns32)
+	    }
-{
-error("foreach: key type must be int or uint, not %s", key->type->toChars());
-}
-}
 	    if (key && key->storage_class & (STCout | STCref))
 		error("foreach: key cannot be out or ref");
 	    break;
 	case Tclass:
 	case Tstruct:
 #if DMDV2
 	{   /* Look for range iteration, i.e. the properties
 	     * .empty, .next, .retreat, .head and .rear
-	     *    foreach (e; range) { ... }
+	     *    foreach (e; aggr) { ... }
 	     * translates to:
-	     *    for (auto __r = range; !__r.empty; __r.next)
+	     *    for (auto __r = aggr[]; !__r.empty; __r.next)
 	     *    {   auto e = __r.head;
 	     *        ...
 	     *    }
 	     */
 	    if (dim != 1)	// only one argument allowed with ranges
 		goto Lapply;
 	    /* Generate a temporary __r and initialize it with the aggregate.
 	     */
 	    Identifier *id = Identifier::generateId("__r");
-	    VarDeclaration *r = new VarDeclaration(loc, NULL, id, new ExpInitializer(loc, aggr));
+	    aggr = aggr->semantic(sc);
-	    r->semantic(sc);
+	    Expression *rinit = new SliceExp(loc, aggr, NULL, NULL);
+	    rinit = rinit->trySemantic(sc);
+	    if (!rinit)			// if application of [] failed
+		rinit = aggr;
+	    VarDeclaration *r = new VarDeclaration(loc, NULL, id, new ExpInitializer(loc, rinit));
+//	    r->semantic(sc);
+//printf("r: %s, init: %s\n", r->toChars(), r->init->toChars());
 	    Statement *init = new DeclarationStatement(loc, r);
+//printf("init: %s\n", init->toChars());
 	    // !__r.empty
 	    Expression *e = new VarExp(loc, r);
 	    e = new DotIdExp(loc, e, Id::Fempty);
 	    Expression *condition = new NotExp(loc, e);
 	    /* Declaration statement for e:
 	     *    auto e = __r.idhead;
 	     */
 	    e = new VarExp(loc, r);
 	    Expression *einit = new DotIdExp(loc, e, idhead);
-	    einit = einit->semantic(sc);
+//	    einit = einit->semantic(sc);
 	    Argument *arg = (Argument *)arguments->data[0];
 	    VarDeclaration *ve = new VarDeclaration(loc, arg->type, arg->ident, new ExpInitializer(loc, einit));
 	    ve->storage_class |= STCforeach;
-	    ve->storage_class |= arg->storageClass & (STCin | STCout | STCref | STCconst | STCinvariant);
+	    ve->storage_class |= arg->storageClass & (STCin | STCout | STCref | STC_TYPECTOR);
 	    DeclarationExp *de = new DeclarationExp(loc, ve);
 	    Statement *body = new CompoundStatement(loc,
 		new DeclarationStatement(loc, de), this->body);
 	    s = new ForStatement(loc, init, condition, increment, body);
+#if 0
+	    printf("init: %s\n", init->toChars());
+	    printf("condition: %s\n", condition->toChars());
+	    printf("increment: %s\n", increment->toChars());
+	    printf("body: %s\n", body->toChars());
+#endif
 	    s = s->semantic(sc);
 	    break;
 	}
 #endif
 	case Tdelegate:
 TypeDelegate* dgty;
 TypeDelegate* dgty2;
 TypeDelegate* fldeTy;
 	    if (!checkForArgTypes())
+	    {	body = body->semantic(sc);
 		return this;
+	    }
 	    tret = func->type->nextOf();
 	    // Need a variable to hold value from any return statements in body.
 	    if (!sc->func->vresult && tret && tret != Type::tvoid)
 {
 flde = new CastExp(loc, flde, flde->type);
 flde->type = fldeTy;
 }
 		exps->push(flde);
 		e = new CallExp(loc, ec, exps);
 		e->type = Type::tindex;	// don't run semantic() on e
 	    }
 	    else if (tab->ty == Tarray || tab->ty == Tsarray)
 	    {
 		    case Twchar:	flag += 1; break;
 		    case Tdchar:	flag += 2; break;
 		    default:		assert(0);
 		}
 		const char *r = (op == TOKforeach_reverse) ? "R" : "";
-		int j = sprintf(fdname, "_aApply%s%.*s%d", r, 2, fntab[flag], dim);
+#ifdef __MINGW32__
+		int j = sprintf(fdname, "_aApply%s%.*s%lu", r, 2, fntab[flag], dim);
+#else
+		int j = sprintf(fdname, "_aApply%s%.*s%zu", r, 2, fntab[flag], dim);
+#endif
 		assert(j < sizeof(fdname));
 		//LDC: Build arguments.
 		Arguments* args = new Arguments;
 		args->push(new Argument(STCin, tn->arrayOf(), NULL, NULL));
 		if (dim == 2) {
 {
 flde = new CastExp(loc, flde, flde->type);
 flde->type = dgty;
 }
 		exps->push(flde);
 		e = new CallExp(loc, ec, exps);
 		e->type = Type::tindex;	// don't run semantic() on e
 	    }
 	    else if (tab->ty == Tdelegate)
 	    {
 	    break;
 	}
 	default:
 	    error("foreach: %s is not an aggregate type", aggr->type->toChars());
+	    s = NULL;	// error recovery
 	    break;
 }
 sc->noctor--;
 sc->pop();
 return s;
 }
 bool ForeachStatement::checkForArgTypes()
-{
+{   bool result = TRUE;
 for (size_t i = 0; i < arguments->dim; i++)
 {	Argument *arg = (Argument *)arguments->data[i];
 	if (!arg->type)
 	{
 	    error("cannot infer type for %s", arg->ident->toChars());
-	    return FALSE;
+	    arg->type = Type::terror;
-	}
+	    result = FALSE;
-}
+	}
-return TRUE;
+}
+return result;
 }
 int ForeachStatement::hasBreak()
 {
 return TRUE;
 	result |= body->blockExit() & ~(BEbreak | BEcontinue);
 }
 return result;
 }
-int ForeachStatement::fallOffEnd()
-{
-if (body)
-	body->fallOffEnd();
-return TRUE;
-}
 int ForeachStatement::comeFrom()
 {
 if (body)
 	return body->comeFrom();
 this->arg = arg;
 this->lwr = lwr;
 this->upr = upr;
 this->body = body;
-this->enclosinghandler = NULL;
 this->key = NULL;
 }
 Statement *ForeachRangeStatement::syntaxCopy()
 {
 {
 //printf("ForeachRangeStatement::semantic() %p\n", this);
 ScopeDsymbol *sym;
 Statement *s = this;
-enclosinghandler = sc->tfOfTry;
 lwr = lwr->semantic(sc);
 lwr = resolveProperties(sc, lwr);
 lwr = lwr->optimize(WANTvalue);
 if (!lwr->type)
 {
 	return this;
 }
 if (arg->type)
 {
+	arg->type = arg->type->semantic(loc, sc);
 	lwr = lwr->implicitCastTo(sc, arg->type);
 	upr = upr->implicitCastTo(sc, arg->type);
 }
 else
 {
 	result |= body->blockExit() & ~(BEbreak | BEcontinue);
 }
 return result;
 }
-int ForeachRangeStatement::fallOffEnd()
-{
-if (body)
-	body->fallOffEnd();
-return TRUE;
-}
 int ForeachRangeStatement::comeFrom()
 {
 if (body)
 	return body->comeFrom();
 	 */
 	VarExp *v = new VarExp(0, match);
 	condition = new AssignExp(loc, v, condition);
 	condition = condition->semantic(scd);
 }
 else
 	scd = sc->push();
 ifbody = ifbody->semantic(scd);
 scd->pop();
 	else
 	    result |= BEfallthru;
 }
 //printf("IfStatement::blockExit(%p) = x%x\n", this, result);
 return result;
-}
-int IfStatement::fallOffEnd()
-{
-if (!ifbody || ifbody->fallOffEnd() ||
-	!elsebody || elsebody->fallOffEnd())
-	return TRUE;
-return FALSE;
 }
 void IfStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 e = e->semantic(sc);
 		e = e->optimize(WANTvalue | WANTinterpret);
 if (e->op == TOKstring)
 {
 StringExp *se = (StringExp *)e;
-fprintf(stdmsg, "%.*s", (int)se->len, se->string);
+fprintf(stdmsg, "%.*s", (int)se->len, (char*)se->string);
 }
 else
 		    error("string expected for message, not '%s'", e->toChars());
 }
 fprintf(stdmsg, "\n");
 		mem.free(name);
 	    }
 	}
 #endif
 }
+// LDC
+else if (ident == Id::allow_inline)
+{
+sc->func->allowInlining = true;
+}
 else if (ident == Id::startaddress)
 {
 	if (!args || args->dim != 1)
 	    error("function name expected for start address");
 	else
 		body = body->semantic(sc);
 	    }
 	    return this;
 	}
 }
-// LDC
-else if (ident == Id::allow_inline)
-{
-sc->func->allowInlining = true;
-}
 else
 error("unrecognized pragma(%s)", ident->toChars());
 if (body)
 {
 	result |= body->blockExit();
 #endif
 return result;
 }
-int PragmaStatement::fallOffEnd()
-{
-if (body)
-	return body->fallOffEnd();
-return TRUE;
-}
 void PragmaStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("pragma (");
 buf->writestring(ident->toChars());
 : Statement(loc)
 {
 condition = c;
 body = b;
 sdefault = NULL;
-tf = NULL;
 cases = NULL;
 hasNoDefault = 0;
 hasVars = 0;
 // LDC
-enclosinghandler = NULL;
+enclosingScopeExit = NULL;
 }
 Statement *SwitchStatement::syntaxCopy()
 {
 SwitchStatement *s = new SwitchStatement(loc,
 }
 Statement *SwitchStatement::semantic(Scope *sc)
 {
 //printf("SwitchStatement::semantic(%p)\n", this);
-tf = sc->tf;
 assert(!cases);		// ensure semantic() is only run once
-enclosinghandler = sc->tfOfTry;
+// LDC
+enclosingScopeExit = sc->enclosingScopeExit;
 condition = condition->semantic(sc);
 condition = resolveProperties(sc, condition);
 if (condition->type->isString())
 {
 }
 if (!sc->sw->sdefault)
 {	hasNoDefault = 1;
-	if (global.params.warnings)
+	warning("switch statement has no default");
-	{   warning("%s: switch statement has no default", loc.toChars());
-	}
 	// Generate runtime error if the default is hit
 	Statements *a = new Statements();
 	CompoundStatement *cs;
 	Statement *s;
 	    s = new ExpStatement(loc, e);
 	}
 	a->reserve(4);
 	a->push(body);
-	a->push(new BreakStatement(loc, NULL));
+	// LDC needs semantic to be run on break
+	Statement *breakstmt = new BreakStatement(loc, NULL);
+	breakstmt->semantic(sc);
+	a->push(breakstmt);
 	sc->sw->sdefault = new DefaultStatement(loc, s);
 	a->push(sc->sw->sdefault);
 	cs = new CompoundStatement(loc, a);
 	body = cs;
 }
 	result |= BEfallthru;
 return result;
 }
-int SwitchStatement::fallOffEnd()
-{
-if (body)
-	body->fallOffEnd();
-return TRUE;	// need to do this better
-}
 void SwitchStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("switch (");
 condition->toCBuffer(buf, hgs);
 this->statement = s;
 index = 0;
 cblock = NULL;
 bodyBB = NULL;
 llvmIdx = NULL;
+// LDC
+enclosingScopeExit = NULL;
 }
 Statement *CaseStatement::syntaxCopy()
 {
 CaseStatement *s = new CaseStatement(loc, exp->syntaxCopy(), statement->syntaxCopy());
 //printf("CaseStatement::semantic() %s\n", toChars());
 exp = exp->semantic(sc);
 if (sw)
 {
+	// LDC
+	enclosingScopeExit = sc->enclosingScopeExit;
+	if (enclosingScopeExit != sw->enclosingScopeExit)
+	{
+	    error("case must be inside the same try, synchronized or volatile level as switch");
+	}
 	exp = exp->implicitCastTo(sc, sw->condition->type);
 	exp = exp->optimize(WANTvalue | WANTinterpret);
 	/* This is where variables are allowed as case expressions.
 	 */
 	    {
 		gcs->cs = this;
 		sw->gotoCases.remove(i);	// remove from array
 	    }
 	}
+#if IN_DMD
 	if (sc->sw->tf != sc->tf)
 	    error("switch and case are in different finally blocks");
+#endif
 }
 else
 	error("case not in switch statement");
 statement = statement->semantic(sc);
 return this;
 int CaseStatement::blockExit()
 {
 return statement->blockExit();
 }
-int CaseStatement::fallOffEnd()
-{
-return statement->fallOffEnd();
-}
 int CaseStatement::comeFrom()
 {
 return TRUE;
 }
 this->statement = s;
 #if IN_GCC
 +    cblock = NULL;
 #endif
 bodyBB = NULL;
+// LDC
+enclosingScopeExit = NULL;
 }
 Statement *DefaultStatement::syntaxCopy()
 {
 DefaultStatement *s = new DefaultStatement(loc, statement->syntaxCopy());
 	{
 	    error("switch statement already has a default");
 	}
 	sc->sw->sdefault = this;
-	if (sc->sw->tf != sc->tf)
+	// LDC
-	    error("switch and default are in different finally blocks");
+	enclosingScopeExit = sc->enclosingScopeExit;
+	if (enclosingScopeExit != sc->sw->enclosingScopeExit)
+	{
+	    error("default must be inside the same try, synchronized or volatile level as switch");
+	}
 }
 else
 	error("default not in switch statement");
 statement = statement->semantic(sc);
 return this;
 int DefaultStatement::blockExit()
 {
 return statement->blockExit();
 }
-int DefaultStatement::fallOffEnd()
-{
-return statement->fallOffEnd();
-}
 int DefaultStatement::comeFrom()
 {
 return TRUE;
 }
 GotoDefaultStatement::GotoDefaultStatement(Loc loc)
 : Statement(loc)
 {
 sw = NULL;
-enclosinghandler = NULL;
 }
 Statement *GotoDefaultStatement::syntaxCopy()
 {
 GotoDefaultStatement *s = new GotoDefaultStatement(loc);
 return s;
 }
 Statement *GotoDefaultStatement::semantic(Scope *sc)
 {
-enclosinghandler = sc->tfOfTry;
 sw = sc->sw;
 if (!sw)
 	error("goto default not in switch statement");
 return this;
 }
 int GotoDefaultStatement::blockExit()
 {
 return BEgoto;
 }
-int GotoDefaultStatement::fallOffEnd()
-{
-return FALSE;
-}
 void GotoDefaultStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("goto default;\n");
 }
 GotoCaseStatement::GotoCaseStatement(Loc loc, Expression *exp)
 : Statement(loc)
 {
 cs = NULL;
 this->exp = exp;
-enclosinghandler = NULL;
 sw = NULL;
 }
 Statement *GotoCaseStatement::syntaxCopy()
 {
 return s;
 }
 Statement *GotoCaseStatement::semantic(Scope *sc)
 {
-enclosinghandler = sc->tfOfTry;
 if (exp)
 	exp = exp->semantic(sc);
 if (!sc->sw)
 	error("goto case not in switch statement");
 int GotoCaseStatement::blockExit()
 {
 return BEgoto;
 }
-int GotoCaseStatement::fallOffEnd()
-{
-return FALSE;
-}
 void GotoCaseStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("goto case");
 if (exp)
 int SwitchErrorStatement::blockExit()
 {
 return BEthrow;
 }
-int SwitchErrorStatement::fallOffEnd()
-{
-return FALSE;
-}
 void SwitchErrorStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("SwitchErrorStatement::toCBuffer()");
 buf->writenl();
 ReturnStatement::ReturnStatement(Loc loc, Expression *exp)
 : Statement(loc)
 {
 this->exp = exp;
-this->enclosinghandler = NULL;
 }
 Statement *ReturnStatement::syntaxCopy()
 {
 Expression *e = NULL;
 }
 Statement *ReturnStatement::semantic(Scope *sc)
 {
 //printf("ReturnStatement::semantic() %s\n", toChars());
-this->enclosinghandler = sc->tfOfTry;
 FuncDeclaration *fd = sc->parent->isFuncDeclaration();
 Scope *scx = sc;
 int implicit0 = 0;
 	exp = new IntegerExp(0);
 }
 if (sc->incontract || scx->incontract)
 	error("return statements cannot be in contracts");
-if (sc->tf || scx->tf)
+if (sc->enclosingFinally || scx->enclosingFinally)
 	error("return statements cannot be in finally, scope(exit) or scope(success) bodies");
 if (fd->isCtorDeclaration())
 {
 	// Constructors implicitly do:
 	    }
 	}
 	else if (tbret->ty != Tvoid)
 	{
 	    exp = exp->implicitCastTo(sc, tret);
+	    exp = exp->optimize(WANTvalue);
 	}
 }
 else if (fd->inferRetType)
 {
 	if (fd->type->nextOf())
 	    exp = new AssignExp(loc, v, exp);
 	    exp = exp->semantic(sc);
 	}
-	if (((TypeFunction *)fd->type)->isref)
+	if (((TypeFunction *)fd->type)->isref && !fd->isCtorDeclaration())
 	{   // Function returns a reference
 	    if (tbret->isMutable())
 		exp = exp->modifiableLvalue(sc, exp);
 	    else
 		exp = exp->toLvalue(sc, exp);
 if (exp && exp->canThrow())
 	result |= BEthrow;
 return result;
 }
-int ReturnStatement::fallOffEnd()
-{
-return FALSE;
-}
 void ReturnStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->printf("return ");
 if (exp)
 BreakStatement::BreakStatement(Loc loc, Identifier *ident)
 : Statement(loc)
 {
 this->ident = ident;
-this->enclosinghandler = NULL;
 }
 Statement *BreakStatement::syntaxCopy()
 {
 BreakStatement *s = new BreakStatement(loc, ident);
 }
 Statement *BreakStatement::semantic(Scope *sc)
 {
 //printf("BreakStatement::semantic()\n");
-enclosinghandler = sc->tfOfTry;
 // If:
 //	break Identifier;
 if (ident)
 {
 	Scope *scx;
 	    {
 		Statement *s = ls->statement;
 		if (!s->hasBreak())
 		    error("label '%s' has no break", ident->toChars());
-		if (ls->tf != sc->tf)
+		if (ls->enclosingFinally != sc->enclosingFinally)
 		    error("cannot break out of finally block");
 		this->target = ls;
 		return this;
 	    }
 {
 //printf("BreakStatement::blockExit(%p) = x%x\n", this, ident ? BEgoto : BEbreak);
 return ident ? BEgoto : BEbreak;
 }
-int BreakStatement::fallOffEnd()
-{
-return FALSE;
-}
 void BreakStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("break");
 if (ident)
 ContinueStatement::ContinueStatement(Loc loc, Identifier *ident)
 : Statement(loc)
 {
 this->ident = ident;
-this->enclosinghandler = NULL;
 }
 Statement *ContinueStatement::syntaxCopy()
 {
 ContinueStatement *s = new ContinueStatement(loc, ident);
 return s;
 }
 Statement *ContinueStatement::semantic(Scope *sc)
 {
-enclosinghandler = sc->tfOfTry;
 //printf("ContinueStatement::semantic() %p\n", this);
 if (ident)
 {
 	Scope *scx;
 	FuncDeclaration *thisfunc = sc->func;
 	    {
 		Statement *s = ls->statement;
 		if (!s->hasContinue())
 		    error("label '%s' has no continue", ident->toChars());
-		if (ls->tf != sc->tf)
+		if (ls->enclosingFinally != sc->enclosingFinally)
 		    error("cannot continue out of finally block");
 		this->target = ls;
 		return this;
 	    }
 int ContinueStatement::blockExit()
 {
 return ident ? BEgoto : BEcontinue;
 }
-int ContinueStatement::fallOffEnd()
-{
-return FALSE;
-}
 void ContinueStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("continue");
 if (ident)
 : Statement(loc)
 {
 this->exp = exp;
 this->body = body;
 this->esync = NULL;
-this->enclosinghandler = NULL;
 // LDC
 this->llsync = NULL;
 }
 SynchronizedStatement::SynchronizedStatement(Loc loc, elem *esync, Statement *body)
 : Statement(loc)
 {
 this->exp = NULL;
 this->body = body;
 this->esync = esync;
-this->enclosinghandler = NULL;
 // LDC
 this->llsync = NULL;
 }
 Statement *SynchronizedStatement::syntaxCopy()
 	    exp = exp->semantic(sc);
 	}
 }
 if (body)
 {
-enclosinghandler = sc->tfOfTry;
+	Statement* oldScopeExit = sc->enclosingScopeExit;
-sc->tfOfTry = new EnclosingSynchro(this);
+	sc->enclosingScopeExit = this;
-body = body->semantic(sc);
+	body = body->semantic(sc);
-sc->tfOfTry = enclosinghandler;
+	sc->enclosingScopeExit = oldScopeExit;
 }
 return this;
 }
 int SynchronizedStatement::hasBreak()
 int SynchronizedStatement::blockExit()
 {
 return body ? body->blockExit() : BEfallthru;
 }
-int SynchronizedStatement::fallOffEnd()
-{
-return body ? body->fallOffEnd() : TRUE;
-}
 void SynchronizedStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("synchronized");
 if (exp)
 else
 	result |= BEfallthru;
 return result;
 }
-int WithStatement::fallOffEnd()
-{
-return body ? body->fallOffEnd() : TRUE;
-}
 /******************************** TryCatchStatement ***************************/
 TryCatchStatement::TryCatchStatement(Loc loc, Statement *body, Array *catches)
 : Statement(loc)
 {
 return TRUE;
 }
 int TryCatchStatement::blockExit()
-{   int result;
+{
 assert(body);
-result = body->blockExit();
+int result = body->blockExit();
+int catchresult = 0;
 for (size_t i = 0; i < catches->dim; i++)
 {
 Catch *c = (Catch *)catches->data[i];
-result |= c->blockExit();
+catchresult |= c->blockExit();
-}
-return result;
+	/* If we're catching Object, then there is no throwing
-}
+	 */
+	Identifier *id = c->type->toBasetype()->isClassHandle()->ident;
-int TryCatchStatement::fallOffEnd()
+	if (i == 0 &&
-{
+	    (id == Id::Object || id == Id::Throwable || id == Id::Exception))
-int result = FALSE;
+	{
+	    result &= ~BEthrow;
-if (body)
+	}
-	result = body->fallOffEnd();
+}
-for (int i = 0; i < catches->dim; i++)
+return result | catchresult;
-{   Catch *c;
+}
-	c = (Catch *)catches->data[i];
-	if (c->handler)
-	    result |= c->handler->fallOffEnd();
-}
-return result;
-}
 void TryCatchStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("try");
 buf->writenl();
 {   ScopeDsymbol *sym;
 //printf("Catch::semantic(%s)\n", ident->toChars());
 #ifndef IN_GCC
-if (sc->tf)
+if (sc->enclosingFinally)
 {
 	/* This is because the _d_local_unwind() gets the stack munged
 	 * up on this. The workaround is to place any try-catches into
 	 * a separate function, and call that.
 	 * To fix, have the compiler automatically convert the finally
 TryFinallyStatement::TryFinallyStatement(Loc loc, Statement *body, Statement *finalbody)
 : Statement(loc)
 {
 this->body = body;
 this->finalbody = finalbody;
-this->enclosinghandler = NULL;
 }
 Statement *TryFinallyStatement::syntaxCopy()
 {
 TryFinallyStatement *s = new TryFinallyStatement(loc,
 Statement *TryFinallyStatement::semantic(Scope *sc)
 {
 //printf("TryFinallyStatement::semantic()\n");
-enclosinghandler = sc->tfOfTry;
+Statement* oldScopeExit = sc->enclosingScopeExit;
-sc->tfOfTry = new EnclosingTryFinally(this);
+sc->enclosingScopeExit = this;
 body = body->semantic(sc);
-sc->tfOfTry = enclosinghandler;
+sc->enclosingScopeExit = oldScopeExit;
 sc = sc->push();
-sc->tf = this;
+sc->enclosingFinally = this;
 sc->sbreak = NULL;
 sc->scontinue = NULL;	// no break or continue out of finally block
 finalbody = finalbody->semantic(sc);
 sc->pop();
 if (!body)
 return TRUE;
 }
 int TryFinallyStatement::blockExit()
 {
-int result = body->blockExit();
+if (body)
-return result;
+	return body->blockExit();
-}
+return BEfallthru;
+}
-int TryFinallyStatement::fallOffEnd()
-{   int result;
-result = body->fallOffEnd();
-//    if (finalbody)
-//	result = finalbody->fallOffEnd();
-return result;
-}
 /****************************** OnScopeStatement ***************************/
 OnScopeStatement::OnScopeStatement(Loc loc, TOK tok, Statement *statement)
 : Statement(loc)
 int ThrowStatement::blockExit()
 {
 return BEthrow;  // obviously
 }
-int ThrowStatement::fallOffEnd()
-{
-return FALSE;
-}
 void ThrowStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->printf("throw ");
 exp->toCBuffer(buf, hgs);
 VolatileStatement::VolatileStatement(Loc loc, Statement *statement)
 : Statement(loc)
 {
 this->statement = statement;
-this->enclosinghandler = NULL;
 }
 Statement *VolatileStatement::syntaxCopy()
 {
 VolatileStatement *s = new VolatileStatement(loc,
 Statement *VolatileStatement::semantic(Scope *sc)
 {
 if (statement)
 {
-enclosinghandler = sc->tfOfTry;
+	Statement* oldScopeExit = sc->enclosingScopeExit;
-sc->tfOfTry = new EnclosingVolatile(this);
+	sc->enclosingScopeExit = this;
 	statement = statement->semantic(sc);
-sc->tfOfTry = enclosinghandler;
+	sc->enclosingScopeExit = oldScopeExit;
 }
 return this;
 }
 Statements *VolatileStatement::flatten(Scope *sc)
 int VolatileStatement::blockExit()
 {
 return statement ? statement->blockExit() : BEfallthru;
 }
-int VolatileStatement::fallOffEnd()
-{
-return statement ? statement->fallOffEnd() : TRUE;
-}
 void VolatileStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("volatile");
 if (statement)
 GotoStatement::GotoStatement(Loc loc, Identifier *ident)
 : Statement(loc)
 {
 this->ident = ident;
 this->label = NULL;
-this->tf = NULL;
+this->enclosingFinally = NULL;
-this->enclosinghandler = NULL;
+this->enclosingScopeExit = NULL;
 }
 Statement *GotoStatement::syntaxCopy()
 {
 GotoStatement *s = new GotoStatement(loc, ident);
 Statement *GotoStatement::semantic(Scope *sc)
 {   FuncDeclaration *fd = sc->parent->isFuncDeclaration();
 //printf("GotoStatement::semantic()\n");
-tf = sc->tf;
+enclosingFinally = sc->enclosingFinally;
-enclosinghandler = sc->tfOfTry;
+enclosingScopeExit = sc->enclosingScopeExit;
 label = fd->searchLabel(ident);
 if (!label->statement && sc->fes)
 {
 	/* Either the goto label is forward referenced or it
 	 * is in the function that the enclosing foreach is in.
 	a->push(this);
 	s = new CompoundStatement(loc, a);
 	sc->fes->gotos.push(s);		// 'look at this later' list
 	return s;
 }
-if (label->statement && label->statement->tf != sc->tf)
+if (label->statement && label->statement->enclosingFinally != sc->enclosingFinally)
 	error("cannot goto in or out of finally block");
 return this;
 }
 int GotoStatement::blockExit()
 {
 //printf("GotoStatement::blockExit(%p)\n", this);
 return BEgoto;
 }
-int GotoStatement::fallOffEnd()
-{
-return FALSE;
-}
 void GotoStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("goto ");
 buf->writestring(ident->toChars());
 LabelStatement::LabelStatement(Loc loc, Identifier *ident, Statement *statement)
 : Statement(loc)
 {
 this->ident = ident;
 this->statement = statement;
-this->tf = NULL;
+this->enclosingFinally = NULL;
-this->enclosinghandler = NULL;
+this->enclosingScopeExit = NULL;
 this->lblock = NULL;
 this->isReturnLabel = 0;
 this->asmLabel = false;
 }
 ls = fd->searchLabel(ident);
 if (ls->statement)
 	error("Label '%s' already defined", ls->toChars());
 else
 	ls->statement = this;
-tf = sc->tf;
-enclosinghandler = sc->tfOfTry;
+enclosingFinally = sc->enclosingFinally;
+enclosingScopeExit = sc->enclosingScopeExit;
 sc = sc->push();
 sc->scopesym = sc->enclosing->scopesym;
 sc->callSuper |= CSXlabel;
 sc->slabel = this;
 if (statement)
 {
 //printf("LabelStatement::blockExit(%p)\n", this);
 return statement ? statement->blockExit() : BEfallthru;
 }
-int LabelStatement::fallOffEnd()
-{
-return statement ? statement->fallOffEnd() : TRUE;
-}
 int LabelStatement::comeFrom()
 {
 //printf("LabelStatement::comeFrom()\n");
 return TRUE;
 LabelDsymbol::LabelDsymbol(Identifier *ident)
 	: Dsymbol(ident)
 {
 statement = NULL;
+#if IN_GCC
+asmLabelNum = 0;
+#endif
 }
 LabelDsymbol *LabelDsymbol::isLabel()		// is this a LabelDsymbol()?
 {
 return this;
 }

Mercurial > projects > ldc

comparison dmd2/statement.c @ 1452:638d16625da2