Added while loops to DECORATE

src/thingdef/thingdef_exp.h

@@ -48,6 +48,7 @@
 #define RESOLVE(p,c) if (p!=NULL) p = p->Resolve(c)
 #define ABORT(p) if (!(p)) { delete this; return NULL; }
 #define SAFE_RESOLVE(p,c) RESOLVE(p,c); ABORT(p) 
+#define SAFE_RESOLVE_OPT(p,c) if (p!=NULL) { SAFE_RESOLVE(p,c) }
 
 class VMFunctionBuilder;
 class FxJumpStatement;
@@ -927,6 +928,24 @@ public:
 	ExpEmit Emit(VMFunctionBuilder *build);
 };
 
+//==========================================================================
+//
+// FxWhileLoop
+//
+//==========================================================================
+
+class FxWhileLoop : public FxExpression
+{
+	FxExpression *Condition;
+	FxExpression *Code;
+
+public:
+	FxWhileLoop(FxExpression *condition, FxExpression *code, const FScriptPosition &pos);
+	~FxWhileLoop();
+	FxExpression *Resolve(FCompileContext&);
+	ExpEmit Emit(VMFunctionBuilder *build);
+};
+
 //==========================================================================
 //
 // FxJumpStatement

src/thingdef/thingdef_expression.cpp

@@ -3857,6 +3857,107 @@ ExpEmit FxIfStatement::Emit(VMFunctionBuilder *build)
 	return ExpEmit();
 }
 
+//==========================================================================
+//
+// FxWhileLoop
+//
+//==========================================================================
+
+FxWhileLoop::FxWhileLoop(FxExpression *condition, FxExpression *code, const FScriptPosition &pos)
+: FxExpression(pos), Condition(condition), Code(code)
+{
+	ValueType = TypeVoid;
+}
+
+FxWhileLoop::~FxWhileLoop()
+{
+	SAFE_DELETE(Condition);
+	SAFE_DELETE(Code);
+}
+
+FxExpression *FxWhileLoop::Resolve(FCompileContext &ctx)
+{
+	CHECKRESOLVED();
+	SAFE_RESOLVE(Condition, ctx);
+	SAFE_RESOLVE_OPT(Code, ctx);
+
+	ctx.HandleJumps(TK_Break, this);
+	ctx.HandleJumps(TK_Continue, this);
+
+	if (Condition->ValueType != TypeBool)
+	{
+		Condition = new FxBoolCast(Condition);
+		SAFE_RESOLVE(Condition, ctx);
+	}
+
+	if (Condition->isConstant())
+	{
+		if (static_cast<FxConstant *>(Condition)->GetValue().GetBool() == false)
+		{ // Nothing happens
+			FxExpression *nop = new FxNop(ScriptPosition);
+			delete this;
+			return nop;
+		}
+		else if (Code == nullptr)
+		{ // "while (true) { }"
+		  // Someone could be using this for testing.
+			ScriptPosition.Message(MSG_WARNING, "Infinite empty loop");
+		}
+	}
+
+	return this;
+}
+
+ExpEmit FxWhileLoop::Emit(VMFunctionBuilder *build)
+{
+	assert(Condition->ValueType == TypeBool);
+
+	size_t loopstart, loopend;
+	size_t jumpspot;
+
+	// Evaluate the condition and execute/break out of the loop.
+	loopstart = build->GetAddress();
+	if (!Condition->isConstant())
+	{
+		ExpEmit cond = Condition->Emit(build);
+		build->Emit(OP_TEST, cond.RegNum, 0);
+		jumpspot = build->Emit(OP_JMP, 0);
+		cond.Free(build);
+	}
+	else assert(static_cast<FxConstant *>(Condition)->GetValue().GetBool() == true);
+
+	// Execute the loop's content.
+	if (Code != nullptr)
+	{
+		ExpEmit code = Code->Emit(build);
+		code.Free(build);
+	}
+
+	// Loop back.
+	build->Backpatch(build->Emit(OP_JMP, 0), loopstart);
+	loopend = build->GetAddress();
+
+	if (!Condition->isConstant()) 
+	{
+		build->Backpatch(jumpspot, loopend);
+	}
+
+	// Give a proper address to any break/continue statement within this loop.
+	for (unsigned int i = 0; i < JumpAddresses.Size(); i++)
+	{
+		if (JumpAddresses[i]->Token == TK_Break)
+		{
+			build->Backpatch(JumpAddresses[i]->Address, loopend);
+		}
+		else
+		{ // Continue statement.
+			build->Backpatch(JumpAddresses[i]->Address, loopstart);
+		}
+	}
+
+	return ExpEmit();
+}
+
 //==========================================================================
 //
 // FxJumpStatement

src/thingdef/thingdef_states.cpp

@@ -480,6 +480,27 @@ static FxExpression *ParseIf(FScanner &sc, FState state, FString statestring, Ba
 	return add;
 }
 
+static FxExpression *ParseWhile(FScanner &sc, FState state, FString statestring, Baggage &bag,
+	PPrototype *&retproto, bool &lastwasret)
+{
+	FxExpression *cond, *code;
+	PPrototype *proto;
+	bool ret;
+
+	sc.MustGetStringName("(");
+	cond = ParseExpression(sc, bag.Info);
+	sc.MustGetStringName(")");
+	sc.MustGetStringName("{"); // Enforce braces like for if statements.
+
+	code = ParseActions(sc, state, statestring, bag, proto, ret);
+	sc.MustGetString();
+
+	retproto = ReturnCheck(retproto, proto, sc);
+	lastwasret = false; // A while loop always jumps back.
+
+	return new FxWhileLoop(cond, code, sc);
+}
+
 FxExpression *ParseActions(FScanner &sc, FState state, FString statestring, Baggage &bag,
 						   PPrototype *&retproto, bool &endswithret)
 {
@@ -505,9 +526,13 @@ FxExpression *ParseActions(FScanner &sc, FState state, FString statestring, Bagg
 		FxExpression *add;
 		lastwasret = false;
 		if (sc.Compare("if"))
-		{ // Hangle an if statement
+		{ // Handle an if statement
 			add = ParseIf(sc, state, statestring, bag, proto, lastwasret);
 		}
+		else if (sc.Compare("while"))
+		{ // Handle a while loop
+			add = ParseWhile(sc, state, statestring, bag, proto, lastwasret);
+		}
 		else if (sc.Compare("return"))
 		{ // Handle a return statement
 			lastwasret = true;

src/zscript/vmbuilder.cpp

@@ -436,6 +436,17 @@ bool VMFunctionBuilder::RegAvailability::Reuse(int reg)
 	return true;
 }
 
+//==========================================================================
+//
+// VMFunctionBuilder :: GetAddress
+//
+//==========================================================================
+
+size_t VMFunctionBuilder::GetAddress()
+{
+	return Code.Size();
+}
+
 //==========================================================================
 //
 // VMFunctionBuilder :: Emit

src/zscript/vmbuilder.h

@@ -34,6 +34,9 @@ public:
 	int GetConstantAddress(void *ptr, VM_ATAG tag);
 	int GetConstantString(FString str);
 
+	// Returns the address of the next instruction to be emitted.
+	size_t GetAddress();
+
 	// Returns the address of the newly-emitted instruction.
 	size_t Emit(int opcode, int opa, int opb, int opc);
 	size_t Emit(int opcode, int opa, VM_SHALF opbc);