botc: comparison parser.cxx

-:5cd91fd1526c
+:1b35c9985989
 // Main parser code. Begins read of the script file, checks the syntax of it
 // and writes the data to the object file via ObjWriter - which also takes care
 // of necessary buffering so stuff is written in the correct order.
 void ScriptReader::BeginParse (ObjWriter* w) {
 	while (Next()) {
+		// ============================================================
 		if (!token.icompare ("state")) {
 			MUST_TOPLEVEL
 			MustString ();
 			g_CurState = token;
 			g_GotMainLoop = false;
 			continue;
 		}
+		// ============================================================
 		if (!token.icompare ("event")) {
 			MUST_TOPLEVEL
 			// Event definition
 			MustString ();
 			w->Write<word> (e->number);
 			g_NumEvents++;
 			continue;
 		}
+		// ============================================================
 		if (!token.icompare ("mainloop")) {
 			MUST_TOPLEVEL
 			MustNext ("{");
 			// Mode must be set before dataheader is written here!
 			g_CurMode = MODE_MAINLOOP;
 			w->Write (DH_MAINLOOP);
 			continue;
 		}
+		// ============================================================
 		if (!token.icompare ("onenter") || !token.icompare ("onexit")) {
 			MUST_TOPLEVEL
 			bool onenter = !token.compare ("onenter");
 			MustNext ("{");
 			g_CurMode = onenter ? MODE_ONENTER : MODE_ONEXIT;
 			w->Write (onenter ? DH_ONENTER : DH_ONEXIT);
 			continue;
 		}
+		// ============================================================
 		if (!token.compare ("var")) {
 			// For now, only globals are supported
 			if (g_CurMode != MODE_TOPLEVEL || g_CurState.len())
 				ParserError ("variables must only be global for now");
 			MustNext (";");
 			continue;
 		}
+		// ============================================================
 		// Label
 		if (!PeekNext().compare (":")) {
 			MUST_NOT_TOPLEVEL
 			if (IsKeyword (token))
 			w->AddMark (MARKTYPE_LABEL, token);
 			MustNext (":");
 			continue;
 		}
+		// ============================================================
 		// Goto
 		if (!token.icompare ("goto")) {
 			MUST_NOT_TOPLEVEL
 			// Get the name of the label
 			w->AddReference (m);
 			MustNext (";");
 			continue;
 		}
+		// ============================================================
 		// If
 		if (!token.icompare ("if")) {
 			MUST_NOT_TOPLEVEL
 			PushBlockStack ();
 			blockstack[g_BlockStackCursor].mark1 = marknum;
 			blockstack[g_BlockStackCursor].type = BLOCKTYPE_IF;
 			continue;
 		}
+		// ============================================================
 		// While
 		if (!token.compare ("while")) {
 			MUST_NOT_TOPLEVEL
 			PushBlockStack ();
 			blockstack[g_BlockStackCursor].mark2 = mark2;
 			blockstack[g_BlockStackCursor].type = BLOCKTYPE_WHILE;
 			continue;
 		}
+		// ============================================================
+		// For loop
+		if (!token.icompare ("for")) {
+			MUST_NOT_TOPLEVEL
+			PushBlockStack ();
+			// Initializer
+			MustNext ("(");
+			MustNext ();
+			DataBuffer* init = ParseStatement (w);
+			MustNext (";");
+			// Condition
+			MustNext ();
+			DataBuffer* cond = ParseExpression (TYPE_INT);
+			MustNext (";");
+			// Incrementor
+			MustNext ();
+			DataBuffer* incr = ParseStatement (w);
+			MustNext (")");
+			MustNext ("{");
+			// First, write out the initializer
+			w->WriteBuffer (init);
+			// Init two marks
+			int mark1 = w->AddMark (MARKTYPE_INTERNAL, "");
+			int mark2 = w->AddMark (MARKTYPE_INTERNAL, "");
+			// Add the condition
+			w->WriteBuffer (cond);
+			w->Write<long> (DH_IFNOTGOTO);
+			w->AddReference (mark2);
+			// Store the marks and incrementor
+			blockstack[g_BlockStackCursor].mark1 = mark1;
+			blockstack[g_BlockStackCursor].mark2 = mark2;
+			blockstack[g_BlockStackCursor].buffer1 = incr;
+			blockstack[g_BlockStackCursor].type = BLOCKTYPE_FOR;
+			continue;
+		}
+		// ============================================================
 		if (!token.compare ("}")) {
 			// Closing brace
 			// If we're in the block stack, we're descending down from it now
 			if (g_BlockStackCursor > 0) {
 				switch (info->type) {
 				case BLOCKTYPE_IF:
 					// Adjust the closing mark.
 					w->MoveMark (info->mark1);
 					break;
+				case BLOCKTYPE_FOR:
+					// Write the incrementor at the end of the loop block
+					w->WriteBuffer (info->buffer1);
+					// fall-thru
 				case BLOCKTYPE_WHILE:
 					// Write down the instruction to go back to the start of the loop
 					w->Write (DH_GOTO);
 					w->AddReference (info->mark1);
 			if (!PeekNext().compare (";"))
 				MustNext (";");
 			continue;
 		}
-		// If it's a variable, expect assignment.
+		// ============================================================
-		if (ScriptVar* var = FindGlobalVariable (token)) {
+		// If nothing else, parse it as a statement (which is either
-			DataBuffer* b = ParseAssignment (var);
+		// assignment or expression)
-			MustNext (";");
+		DataBuffer* b = ParseStatement (w);
-			w->WriteBuffer (b);
-			continue;
-		}
-		// If it's not a keyword, parse it as an expression.
-		DataBuffer* b = ParseExpression (TYPE_VOID);
 		w->WriteBuffer (b);
 		MustNext (";");
 	}
 	if (g_CurMode != MODE_TOPLEVEL)
 	// Parse the right operand,
 	MustNext ();
 	DataBuffer* rb = ParseExprValue (reqtype);
+	retbuf->Merge (lb);
 	retbuf->Merge (rb);
-	retbuf->Merge (lb);
 	long dh = DataHeaderByOperator (NULL, oper);
 	retbuf->Write<word> (dh);
 	return retbuf;
 }
 	g_BlockStackCursor++;
 	BlockInformation* info = &blockstack[g_BlockStackCursor];
 	info->type = 0;
 	info->mark1 = 0;
 	info->mark2 = 0;
-}
+	info->buffer1 = NULL;
+}
+DataBuffer* ScriptReader::ParseStatement (ObjWriter* w) {
+	// If it's a variable, expect assignment.
+	if (ScriptVar* var = FindGlobalVariable (token)) {
+		DataBuffer* b = ParseAssignment (var);
+		return b;
+	}
+	// If it's not a keyword, parse it as an expression.
+	DataBuffer* b = ParseExpression (TYPE_VOID);
+	return b;
+}

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx