projects/ldc: dmd/statement.c comparison

comparison dmd/statement.c @ 145:8f704cb9969b trunk

[svn r150] fixes #16 and #17, implements GotoCaseStatement

author	ChristianK
date	Sat, 08 Mar 2008 15:22:07 +0100
parents	a27941d00351
children	86d3bb8ca33e

comparison

equal deleted inserted replaced

-:a27941d00351
+:8f704cb9969b
 UnrolledLoopStatement::UnrolledLoopStatement(Loc loc, Statements *s)
 : Statement(loc)
 {
 statements = s;
+enclosingtry = NULL;
 }
 Statement *UnrolledLoopStatement::syntaxCopy()
 {
 Statements *a = new Statements();
 Statement *UnrolledLoopStatement::semantic(Scope *sc)
 {
 //printf("UnrolledLoopStatement::semantic(this = %p, sc = %p)\n", this, sc);
+enclosingtry = sc->tfOfTry;
 sc->noctor++;
 Scope *scd = sc->push();
 scd->sbreak = this;
 scd->scontinue = this;
 WhileStatement::WhileStatement(Loc loc, Expression *c, Statement *b)
 : Statement(loc)
 {
 condition = c;
 body = b;
+enclosingtry = 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
+enclosingtry = sc->tfOfTry;
 condition = condition->semantic(sc);
 condition = resolveProperties(sc, condition);
 condition = condition->optimize(WANTvalue);
 condition = condition->checkToBoolean();
 DoStatement::DoStatement(Loc loc, Statement *b, Expression *c)
 : Statement(loc)
 {
 body = b;
 condition = c;
+enclosingtry = NULL;
 }
 Statement *DoStatement::syntaxCopy()
 {
 DoStatement *s = new DoStatement(loc, body ? body->syntaxCopy() : NULL, condition->syntaxCopy());
 }
 Statement *DoStatement::semantic(Scope *sc)
 {
+enclosingtry = sc->tfOfTry;
 sc->noctor++;
 if (body)
 	body = body->semanticScope(sc, this, this);
 sc->noctor--;
 condition = condition->semantic(sc);
 {
 this->init = init;
 this->condition = condition;
 this->increment = increment;
 this->body = body;
+this->enclosingtry = NULL;
 }
 Statement *ForStatement::syntaxCopy()
 {
 Statement *i = NULL;
 return s;
 }
 Statement *ForStatement::semantic(Scope *sc)
 {
+enclosingtry = sc->tfOfTry;
 ScopeDsymbol *sym = new ScopeDsymbol();
 sym->parent = sc->scopesym;
 sc = sc->push(sym);
 if (init)
 	init = init->semantic(sc);
 {
 this->op = op;
 this->arguments = arguments;
 this->aggr = aggr;
 this->body = body;
+this->enclosingtry = NULL;
 this->key = NULL;
 this->value = NULL;
 this->func = NULL;
 int i;
 TypeAArray *taa = NULL;
 Type *tn = NULL;
 Type *tnv = NULL;
+enclosingtry = sc->tfOfTry;
 func = sc->func;
 if (func->fes)
 	func = func->fes->func;
 body = b;
 sdefault = NULL;
 cases = NULL;
 hasNoDefault = 0;
 // LLVMDC
-defaultBB = NULL;
+enclosingtry = NULL;
 }
 Statement *SwitchStatement::syntaxCopy()
 {
 SwitchStatement *s = new SwitchStatement(loc,
 Statement *SwitchStatement::semantic(Scope *sc)
 {
 //printf("SwitchStatement::semantic(%p)\n", this);
 assert(!cases);		// ensure semantic() is only run once
+enclosingtry = sc->tfOfTry;
 condition = condition->semantic(sc);
 condition = resolveProperties(sc, condition);
 if (condition->type->isString())
 {
 	// If it's not an array, cast it to one
 : Statement(loc)
 {
 this->exp = exp;
 this->statement = s;
 cblock = NULL;
+bodyBB = NULL;
 }
 Statement *CaseStatement::syntaxCopy()
 {
 CaseStatement *s = new CaseStatement(loc, exp->syntaxCopy(), statement->syntaxCopy());
 {
 this->statement = s;
 #if IN_GCC
 +    cblock = NULL;
 #endif
+bodyBB = NULL;
 }
 Statement *DefaultStatement::syntaxCopy()
 {
 DefaultStatement *s = new DefaultStatement(loc, statement->syntaxCopy());
 GotoDefaultStatement::GotoDefaultStatement(Loc loc)
 : Statement(loc)
 {
 sw = NULL;
+enclosingtry = NULL;
 }
 Statement *GotoDefaultStatement::syntaxCopy()
 {
 GotoDefaultStatement *s = new GotoDefaultStatement(loc);
 return s;
 }
 Statement *GotoDefaultStatement::semantic(Scope *sc)
 {
+enclosingtry = sc->tfOfTry;
 sw = sc->sw;
 if (!sw)
 	error("goto default not in switch statement");
 return this;
 }
 GotoCaseStatement::GotoCaseStatement(Loc loc, Expression *exp)
 : Statement(loc)
 {
 cs = NULL;
 this->exp = exp;
+enclosingtry = NULL;
+sw = NULL;
 }
 Statement *GotoCaseStatement::syntaxCopy()
 {
 Expression *e = exp ? exp->syntaxCopy() : NULL;
 return s;
 }
 Statement *GotoCaseStatement::semantic(Scope *sc)
 {
+enclosingtry = sc->tfOfTry;
 if (exp)
 	exp = exp->semantic(sc);
 if (!sc->sw)
 	error("goto case not in switch statement");
 else
 {
+	sw = sc->sw;
 	sc->sw->gotoCases.push(this);
 	if (exp)
 	{
 	    exp = exp->implicitCastTo(sc, sc->sw->condition->type);
 	    exp = exp->optimize(WANTvalue);
 ReturnStatement::ReturnStatement(Loc loc, Expression *exp)
 : Statement(loc)
 {
 this->exp = exp;
+this->enclosingtry = NULL;
 }
 Statement *ReturnStatement::syntaxCopy()
 {
 Expression *e = NULL;
 }
 Statement *ReturnStatement::semantic(Scope *sc)
 {
 //printf("ReturnStatement::semantic() %s\n", toChars());
+this->enclosingtry = sc->tfOfTry;
 FuncDeclaration *fd = sc->parent->isFuncDeclaration();
 Scope *scx = sc;
 int implicit0 = 0;
 BreakStatement::BreakStatement(Loc loc, Identifier *ident)
 : Statement(loc)
 {
 this->ident = ident;
+this->enclosingtry = NULL;
 }
 Statement *BreakStatement::syntaxCopy()
 {
 BreakStatement *s = new BreakStatement(loc, ident);
 return s;
 }
 Statement *BreakStatement::semantic(Scope *sc)
 {
+enclosingtry = sc->tfOfTry;
 // If:
 //	break Identifier;
 if (ident)
 {
 	Scope *scx;
 		if (!s->hasBreak())
 		    error("label '%s' has no break", ident->toChars());
 		if (ls->tf != sc->tf)
 		    error("cannot break out of finally block");
+		this->target = ls;
 		return this;
 	    }
 	}
 	error("enclosing label '%s' for break not found", ident->toChars());
 }
 ContinueStatement::ContinueStatement(Loc loc, Identifier *ident)
 : Statement(loc)
 {
 this->ident = ident;
+this->enclosingtry = NULL;
 }
 Statement *ContinueStatement::syntaxCopy()
 {
 ContinueStatement *s = new ContinueStatement(loc, ident);
 return s;
 }
 Statement *ContinueStatement::semantic(Scope *sc)
 {
+enclosingtry = sc->tfOfTry;
 //printf("ContinueStatement::semantic() %p\n", this);
 if (ident)
 {
 	Scope *scx;
 	FuncDeclaration *thisfunc = sc->func;
 		if (!s->hasContinue())
 		    error("label '%s' has no continue", ident->toChars());
 		if (ls->tf != sc->tf)
 		    error("cannot continue out of finally block");
+		this->target = ls;
 		return this;
 	    }
 	}
 	error("enclosing label '%s' for continue not found", ident->toChars());
 }
 TryFinallyStatement::TryFinallyStatement(Loc loc, Statement *body, Statement *finalbody)
 : Statement(loc)
 {
 this->body = body;
 this->finalbody = finalbody;
+this->enclosingtry = NULL;
 }
 Statement *TryFinallyStatement::syntaxCopy()
 {
 TryFinallyStatement *s = new TryFinallyStatement(loc,
 }
 Statement *TryFinallyStatement::semantic(Scope *sc)
 {
 //printf("TryFinallyStatement::semantic()\n");
+enclosingtry = sc->tfOfTry;
+sc->tfOfTry = this;
 body = body->semantic(sc);
+sc->tfOfTry = enclosingtry;
 sc = sc->push();
 sc->tf = this;
 sc->sbreak = NULL;
 sc->scontinue = NULL;	// no break or continue out of finally block
 finalbody = finalbody->semantic(sc);
 : Statement(loc)
 {
 this->ident = ident;
 this->label = NULL;
 this->tf = NULL;
+this->enclosingtry = 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;
+enclosingtry = sc->tfOfTry;
 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.
 : Statement(loc)
 {
 this->ident = ident;
 this->statement = statement;
 this->tf = NULL;
+this->enclosingtry = NULL;
 this->lblock = NULL;
 this->isReturnLabel = 0;
 this->llvmBB = NULL;
 }
 if (ls->statement)
 	error("Label '%s' already defined", ls->toChars());
 else
 	ls->statement = this;
 tf = sc->tf;
+enclosingtry = sc->tfOfTry;
 sc = sc->push();
 sc->scopesym = sc->enclosing->scopesym;
 sc->callSuper |= CSXlabel;
 sc->slabel = this;
 if (statement)

Mercurial > projects > ldc

comparison dmd/statement.c @ 145:8f704cb9969b trunk