projects/ldc: dmd/statement.c comparison

comparison dmd/statement.c @ 336:aaade6ded589 trunk

[svn r357] Merged DMD 1.033

author	lindquist
date	Sat, 12 Jul 2008 19:38:31 +0200
parents	d20cf0dec9c1
children	a7a26f538d6e

comparison

equal deleted inserted replaced

-:17b844102023
+:aaade6ded589
 // Compiler implementation of the D programming language
-// Copyright (c) 1999-2007 by Digital Mars
+// Copyright (c) 1999-2008 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.
 int Statement::usesEH()
 {
 return FALSE;
 }
+/* Only valid after semantic analysis
+*/
+int Statement::blockExit()
+{
+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;
 	//exp = exp->optimize(isDeclarationStatement() ? WANTvalue : 0);
 }
 return this;
 }
+int ExpStatement::blockExit()
+{   int result = BEfallthru;
+if (exp)
+{
+	if (exp->op == TOKhalt)
+	    return BEhalt;
+	if (exp->op == TOKassert)
+	{   AssertExp *a = (AssertExp *)exp;
+	    if (a->e1->isBool(FALSE))	// if it's an assert(0)
+		return BEhalt;
+	}
+	if (exp->canThrow())
+	    result |= BEthrow;
+}
+return result;
+}
 int ExpStatement::fallOffEnd()
 {
 if (exp)
 {
 	if (exp->op == TOKassert)
 buf->writestring(");");
 if (!hgs->FLinit.init)
 buf->writenl();
 }
-Statement *CompileStatement::semantic(Scope *sc)
+Statements *CompileStatement::flatten(Scope *sc)
 {
-//printf("CompileStatement::semantic() %s\n", exp->toChars());
+//printf("CompileStatement::flatten() %s\n", exp->toChars());
 exp = exp->semantic(sc);
 exp = resolveProperties(sc, exp);
 exp = exp->optimize(WANTvalue | WANTinterpret);
 if (exp->op != TOKstring)
 {	error("argument to mixin must be a string, not (%s)", exp->toChars());
-	return this;
+	return NULL;
 }
 StringExp *se = (StringExp *)exp;
 se = se->toUTF8(sc);
 Parser p(sc->module, (unsigned char *)se->string, se->len, 0);
 p.loc = loc;
 p.nextToken();
-Statements *statements = new Statements();
+Statements *a = new Statements();
 while (p.token.value != TOKeof)
 {
 	Statement *s = p.parseStatement(PSsemi | PScurlyscope);
-	statements->push(s);
+	a->push(s);
 }
+return a;
-Statement *s = new CompoundStatement(loc, statements);
+}
+Statement *CompileStatement::semantic(Scope *sc)
+{
+//printf("CompileStatement::semantic() %s\n", exp->toChars());
+Statements *a = flatten(sc);
+if (!a)
+	return NULL;
+Statement *s = new CompoundStatement(loc, a);
 return s->semantic(sc);
 }
 /******************************** DeclarationStatement ***************************/
 	    }
 	}
 	i++;
 }
 if (statements->dim == 1 && !isAsmBlockStatement())
-	return s;
+{
+	return (Statement *)statements->data[0];
+}
 return this;
 }
 Statements *CompoundStatement::flatten(Scope *sc)
 {
 return statements;
 }
 ReturnStatement *CompoundStatement::isReturnStatement()
-{   int i;
+{
 ReturnStatement *rs = NULL;
-for (i = 0; i < statements->dim; i++)
+for (int i = 0; i < statements->dim; i++)
-{	Statement *s;
+{	Statement *s = (Statement *) statements->data[i];
-	s = (Statement *) statements->data[i];
 	if (s)
 	{
 	    rs = s->isReturnStatement();
 	    if (rs)
 		break;
 }
 return rs;
 }
 void CompoundStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
-{   int i;
+{
+for (int i = 0; i < statements->dim; i++)
-for (i = 0; i < statements->dim; i++)
+{	Statement *s = (Statement *) statements->data[i];
-{	Statement *s;
-	s = (Statement *) statements->data[i];
 	if (s)
 	    s->toCBuffer(buf, hgs);
 }
 }
 int CompoundStatement::usesEH()
 {
 for (int i = 0; i < statements->dim; i++)
-{	Statement *s;
+{	Statement *s = (Statement *) statements->data[i];
-	s = (Statement *) statements->data[i];
 	if (s && s->usesEH())
 	    return TRUE;
 }
 return FALSE;
+}
+int CompoundStatement::blockExit()
+{
+//printf("CompoundStatement::blockExit(%p) %d\n", this, statements->dim);
+int result = BEfallthru;
+for (size_t i = 0; i < statements->dim; i++)
+{	Statement *s = (Statement *) statements->data[i];
+	if (s)
+	{
+//printf("result = x%x\n", result);
+//printf("%s\n", s->toChars());
+	    if (!(result & BEfallthru) && !s->comeFrom())
+	    {
+		if (global.params.warnings)
+		{   fprintf(stdmsg, "warning - ");
+		    s->error("statement is not reachable");
+		}
+	    }
+	    result &= ~BEfallthru;
+	    result |= s->blockExit();
+	}
+}
+return result;
 }
 int CompoundStatement::fallOffEnd()
 {   int falloff = TRUE;
 }
 int UnrolledLoopStatement::usesEH()
 {
 for (size_t i = 0; i < statements->dim; i++)
-{	Statement *s;
+{	Statement *s = (Statement *) statements->data[i];
-	s = (Statement *) statements->data[i];
 	if (s && s->usesEH())
 	    return TRUE;
 }
 return FALSE;
+}
+int UnrolledLoopStatement::blockExit()
+{
+int result = BEfallthru;
+for (size_t i = 0; i < statements->dim; i++)
+{	Statement *s = (Statement *) statements->data[i];
+	if (s)
+	{
+	    int r = s->blockExit();
+	    result |= r & ~(BEbreak | BEcontinue);
+	}
+}
+return result;
 }
 int UnrolledLoopStatement::fallOffEnd()
 {
 //printf("UnrolledLoopStatement::fallOffEnd()\n");
 	if (s)
 	    s->fallOffEnd();
 }
 return TRUE;
 }
 int UnrolledLoopStatement::comeFrom()
 {   int comefrom = FALSE;
 //printf("UnrolledLoopStatement::comeFrom()\n");
 }
 int ScopeStatement::usesEH()
 {
 return statement ? statement->usesEH() : FALSE;
+}
+int ScopeStatement::blockExit()
+{
+//printf("ScopeStatement::blockExit(%p)\n", statement);
+return statement ? statement->blockExit() : BEfallthru;
 }
 int ScopeStatement::fallOffEnd()
 {
 return statement ? statement->fallOffEnd() : TRUE;
 int WhileStatement::usesEH()
 {
 return body ? body->usesEH() : 0;
 }
+int WhileStatement::blockExit()
+{
+//printf("WhileStatement::blockExit(%p)\n", this);
+int result = BEnone;
+if (condition->canThrow())
+	result |= BEthrow;
+if (condition->isBool(TRUE))
+{
+	if (body)
+	{   result |= body->blockExit();
+	    if (result & BEbreak)
+		result |= BEfallthru;
+	}
+}
+else if (condition->isBool(FALSE))
+{
+	result |= BEfallthru;
+}
+else
+{
+	if (body)
+	    result |= body->blockExit();
+	result |= BEfallthru;
+}
+result &= ~(BEbreak | BEcontinue);
+return result;
+}
 int WhileStatement::fallOffEnd()
 {
 if (body)
 	body->fallOffEnd();
 return TRUE;
 }
 int DoStatement::usesEH()
 {
 return body ? body->usesEH() : 0;
+}
+int DoStatement::blockExit()
+{   int result;
+if (body)
+{	result = body->blockExit();
+	if (result == BEbreak)
+	    return BEfallthru;
+	if (result & BEcontinue)
+	    result |= BEfallthru;
+}
+else
+	result = BEfallthru;
+if (result & BEfallthru)
+{	if (condition->canThrow())
+	    result |= BEthrow;
+	if (!(result & BEbreak) && condition->isBool(TRUE))
+	    result &= ~BEfallthru;
+}
+result &= ~(BEbreak | BEcontinue);
+return result;
 }
 int DoStatement::fallOffEnd()
 {
 if (body)
 }
 int ForStatement::usesEH()
 {
 return (init && init->usesEH()) || body->usesEH();
+}
+int ForStatement::blockExit()
+{   int result = BEfallthru;
+if (init)
+{	result = init->blockExit();
+	if (!(result & BEfallthru))
+	    return result;
+}
+if (condition)
+{	if (condition->canThrow())
+	    result |= BEthrow;
+}
+else
+	result &= ~BEfallthru;	// the body must do the exiting
+if (body)
+{	int r = body->blockExit();
+	if (r & BEbreak)
+	    result |= BEfallthru;
+	result |= r & ~(BEbreak | BEcontinue);
+}
+if (increment && increment->canThrow())
+	result |= BEthrow;
+return result;
 }
 int ForStatement::fallOffEnd()
 {
 if (body)
 		    arg->type = e->type;
 		    Initializer *ie = new ExpInitializer(0, e);
 		    VarDeclaration *v = new VarDeclaration(loc, arg->type, arg->ident, ie);
 		    if (e->isConst())
 			v->storage_class |= STCconst;
-#if V2
-		    else
-			v->storage_class |= STCfinal;
-#endif
 		    var = v;
 		}
 	    }
 	    else
 	    {
 int ForeachStatement::usesEH()
 {
 return body->usesEH();
 }
+int ForeachStatement::blockExit()
+{   int result = BEfallthru;
+if (aggr->canThrow())
+	result |= BEthrow;
+if (body)
+{
+	result |= body->blockExit() & ~(BEbreak | BEcontinue);
+}
+return result;
+}
 int ForeachStatement::fallOffEnd()
 {
 if (body)
 	body->fallOffEnd();
 return TRUE;
 void ForeachStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring(Token::toChars(op));
 buf->writestring(" (");
-int i;
 for (int i = 0; i < arguments->dim; i++)
 {
 	Argument *a = (Argument *)arguments->data[i];
 	if (i)
 	    buf->writestring(", ");
 int IfStatement::usesEH()
 {
 return (ifbody && ifbody->usesEH()) || (elsebody && elsebody->usesEH());
 }
+int IfStatement::blockExit()
+{
+//printf("IfStatement::blockExit(%p)\n", this);
+int result = BEnone;
+if (condition->canThrow())
+	result |= BEthrow;
+if (condition->isBool(TRUE))
+{
+	if (ifbody)
+	    result |= ifbody->blockExit();
+	else
+	    result |= BEfallthru;
+}
+else if (condition->isBool(FALSE))
+{
+	if (elsebody)
+	    result |= elsebody->blockExit();
+	else
+	    result |= BEfallthru;
+}
+else
+{
+	if (ifbody)
+	    result |= ifbody->blockExit();
+	else
+	    result |= BEfallthru;
+	if (elsebody)
+	    result |= elsebody->blockExit();
+	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;
 void ConditionalStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 condition->toCBuffer(buf, hgs);
 buf->writenl();
+buf->writeByte('{');
+buf->writenl();
 if (ifbody)
 	ifbody->toCBuffer(buf, hgs);
+buf->writeByte('}');
+buf->writenl();
 if (elsebody)
 {
 	buf->writestring("else");
 	buf->writenl();
+	buf->writeByte('{');
+	buf->writenl();
 	elsebody->toCBuffer(buf, hgs);
+	buf->writeByte('}');
+	buf->writenl();
 }
 buf->writenl();
 }
 int PragmaStatement::usesEH()
 {
 return body && body->usesEH();
 }
+int PragmaStatement::blockExit()
+{
+int result = BEfallthru;
+#if 0 // currently, no code is generated for Pragma's, so it's just fallthru
+if (arrayExpressionCanThrow(args))
+	result |= BEthrow;
+if (body)
+	result |= body->blockExit();
+#endif
+return result;
+}
 int PragmaStatement::fallOffEnd()
 {
 if (body)
 	return body->fallOffEnd();
 return TRUE;
 }
 int SwitchStatement::usesEH()
 {
 return body ? body->usesEH() : 0;
+}
+int SwitchStatement::blockExit()
+{   int result = BEnone;
+if (condition->canThrow())
+	result |= BEthrow;
+if (body)
+{	result |= body->blockExit();
+	if (result & BEbreak)
+	{   result |= BEfallthru;
+	    result &= ~BEbreak;
+	}
+}
+else
+	result |= BEfallthru;
+return result;
 }
 int SwitchStatement::fallOffEnd()
 {
 if (body)
 int CaseStatement::usesEH()
 {
 return statement->usesEH();
 }
+int CaseStatement::blockExit()
+{
+return statement->blockExit();
+}
 int CaseStatement::fallOffEnd()
 {
 return statement->fallOffEnd();
 }
 return s;
 }
 Statement *DefaultStatement::semantic(Scope *sc)
 {
+//printf("DefaultStatement::semantic()\n");
 if (sc->sw)
 {
 	if (sc->sw->sdefault)
 	{
 	    error("switch statement already has a default");
 }
 int DefaultStatement::usesEH()
 {
 return statement->usesEH();
+}
+int DefaultStatement::blockExit()
+{
+return statement->blockExit();
 }
 int DefaultStatement::fallOffEnd()
 {
 return statement->fallOffEnd();
 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;
 	}
 }
 return this;
 }
+int GotoCaseStatement::blockExit()
+{
+return BEgoto;
+}
 int GotoCaseStatement::fallOffEnd()
 {
 return FALSE;
 }
 /******************************** SwitchErrorStatement ***************************/
 SwitchErrorStatement::SwitchErrorStatement(Loc loc)
 : Statement(loc)
 {
+}
+int SwitchErrorStatement::blockExit()
+{
+return BEthrow;
 }
 int SwitchErrorStatement::fallOffEnd()
 {
 return FALSE;
 	}
 }
 Type *tret = fd->type->nextOf();
 if (fd->tintro)
+	/* We'll be implicitly casting the return expression to tintro
+	 */
 	tret = fd->tintro->nextOf();
 Type *tbret = NULL;
 if (tret)
 	tbret = tret->toBasetype();
 	}
 	return gs;
 }
 if (exp && tbret->ty == Tvoid && !fd->isMain())
-{   Statement *s;
+{
+	/* Replace:
-	s = new ExpStatement(loc, exp);
+	 *	return exp;
+	 * with:
+	 *	exp; return;
+	 */
+	Statement *s = new ExpStatement(loc, exp);
 	loc = 0;
 	exp = NULL;
 	return new CompoundStatement(loc, s, this);
 }
 return this;
+}
+int ReturnStatement::blockExit()
+{   int result = BEreturn;
+if (exp && exp->canThrow())
+	result |= BEthrow;
+return result;
 }
 int ReturnStatement::fallOffEnd()
 {
 return FALSE;
 return s;
 }
 Statement *BreakStatement::semantic(Scope *sc)
 {
+//printf("BreakStatement::semantic()\n");
 enclosinghandler = sc->tfOfTry;
 // If:
 //	break Identifier;
 if (ident)
 {
 	error("break is not inside a loop or switch");
 }
 return this;
 }
+int BreakStatement::blockExit()
+{
+//printf("BreakStatement::blockExit(%p) = x%x\n", this, ident ? BEgoto : BEbreak);
+return ident ? BEgoto : BEbreak;
+}
 int BreakStatement::fallOffEnd()
 {
 return FALSE;
 }
 	error("continue is not inside a loop");
 }
 return this;
 }
+int ContinueStatement::blockExit()
+{
+return ident ? BEgoto : BEcontinue;
+}
 int ContinueStatement::fallOffEnd()
 {
 return FALSE;
 }
 }
 int SynchronizedStatement::usesEH()
 {
 return TRUE;
+}
+int SynchronizedStatement::blockExit()
+{
+return body ? body->blockExit() : BEfallthru;
 }
 int SynchronizedStatement::fallOffEnd()
 {
 return body ? body->fallOffEnd() : TRUE;
 int WithStatement::usesEH()
 {
 return body ? body->usesEH() : 0;
 }
+int WithStatement::blockExit()
+{
+int result = BEnone;
+if (exp->canThrow())
+	result = BEthrow;
+if (body)
+	result |= body->blockExit();
+else
+	result |= BEfallthru;
+return result;
+}
 int WithStatement::fallOffEnd()
 {
 return body ? body->fallOffEnd() : TRUE;
 }
 Statement *TryCatchStatement::semantic(Scope *sc)
 {
 body = body->semanticScope(sc, NULL /*this*/, NULL);
-for (int i = 0; i < catches->dim; i++)
+/* Even if body is NULL, still do semantic analysis on catches
-{   Catch *c;
+*/
+for (size_t i = 0; i < catches->dim; i++)
-	c = (Catch *)catches->data[i];
+{   Catch *c = (Catch *)catches->data[i];
 	c->semantic(sc);
 	// Determine if current catch 'hides' any previous catches
-	for (int j = 0; j < i; j++)
+	for (size_t j = 0; j < i; j++)
 	{   Catch *cj = (Catch *)catches->data[j];
 	    char *si = c->loc.toChars();
 	    char *sj = cj->loc.toChars();
 	    if (c->type->toBasetype()->implicitConvTo(cj->type->toBasetype()))
 }
 int TryCatchStatement::usesEH()
 {
 return TRUE;
+}
+int TryCatchStatement::blockExit()
+{   int result;
+assert(body);
+result = body->blockExit();
+for (size_t i = 0; i < catches->dim; i++)
+{
+Catch *c = (Catch *)catches->data[i];
+result |= c->blockExit();
+}
+return result;
 }
 int TryCatchStatement::fallOffEnd()
 {
 int result = FALSE;
 {
 buf->writestring("try");
 buf->writenl();
 if (body)
 body->toCBuffer(buf, hgs);
-int i;
+for (size_t i = 0; i < catches->dim; i++)
-for (i = 0; i < catches->dim; i++)
 {
 Catch *c = (Catch *)catches->data[i];
 c->toCBuffer(buf, hgs);
 }
 }
 handler = handler->semantic(sc);
 sc->pop();
 }
+int Catch::blockExit()
+{
+return handler ? handler->blockExit() : BEfallthru;
+}
 void Catch::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring("catch");
 if (type)
 {   buf->writebyte('(');
 buf->writebyte(')');
 }
 buf->writenl();
 buf->writebyte('{');
 buf->writenl();
-handler->toCBuffer(buf, hgs);
+if (handler)
+	handler->toCBuffer(buf, hgs);
 buf->writebyte('}');
 buf->writenl();
 }
 /****************************** TryFinallyStatement ***************************/
 int TryFinallyStatement::usesEH()
 {
 return TRUE;
 }
+int TryFinallyStatement::blockExit()
+{
+int result = body->blockExit();
+return result;
+}
 int TryFinallyStatement::fallOffEnd()
 {   int result;
 result = body ? body->fallOffEnd() : TRUE;
 //    if (finalbody)
 Statement *OnScopeStatement::semantic(Scope *sc)
 {
 /* semantic is called on results of scopeCode() */
 return this;
+}
+int OnScopeStatement::blockExit()
+{   // At this point, this statement is just an empty placeholder
+return BEfallthru;
 }
 void OnScopeStatement::toCBuffer(OutBuffer *buf, HdrGenState *hgs)
 {
 buf->writestring(Token::toChars(tok));
 if (!exp->type->toBasetype()->isClassHandle())
 	error("can only throw class objects, not type %s", exp->type->toChars());
 return this;
 }
+int ThrowStatement::blockExit()
+{
+return BEthrow;  // obviously
+}
 int ThrowStatement::fallOffEnd()
 {
 return FALSE;
 }
 	    a->data[i] = s;
 	}
 }
 return a;
+}
+int VolatileStatement::blockExit()
+{
+return statement ? statement->blockExit() : BEfallthru;
 }
 int VolatileStatement::fallOffEnd()
 {
 return statement ? statement->fallOffEnd() : TRUE;
 	return s;
 }
 if (label->statement && label->statement->tf != sc->tf)
 	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;
 int LabelStatement::usesEH()
 {
 return statement ? statement->usesEH() : FALSE;
 }
+int LabelStatement::blockExit()
+{
+//printf("LabelStatement::blockExit(%p)\n", this);
+return statement ? statement->blockExit() : BEfallthru;
+}
 int LabelStatement::fallOffEnd()
 {
 return statement ? statement->fallOffEnd() : TRUE;
 }

Mercurial > projects > ldc

comparison dmd/statement.c @ 336:aaade6ded589 trunk