botc: comparison parser.cxx

-:96f60ca748a0
+:bc9317d1b9c9
 	ParserError ("%s-statements may only be defined at top level!", token.chars());
 #define MUST_NOT_TOPLEVEL if (g_CurMode == MODE_TOPLEVEL) \
 	ParserError ("%s-statements may not be defined at top level!", token.chars());
-#define SCOPE(n) blockstack[g_BlockStackCursor - n]
+#define SCOPE(n) scopestack[g_ScopeCursor - n]
 int g_NumStates = 0;
 int g_NumEvents = 0;
 int g_CurMode = MODE_TOPLEVEL;
 str g_CurState = "";
 bool g_stateSpawnDefined = false;
 bool g_GotMainLoop = false;
-unsigned int g_BlockStackCursor = 0;
+unsigned int g_ScopeCursor = 0;
 DataBuffer* g_IfExpression = NULL;
 bool g_CanElse = false;
 // ============================================================================
 // 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::ParseBotScript (ObjWriter* w) {
 	// Zero the entire block stack first
 	for (int i = 0; i < MAX_STRUCTSTACK; i++)
-		memset (&blockstack[i], 0, sizeof (BlockInformation));
+		memset (&scopestack[i], 0, sizeof (BlockInformation));
 	while (Next()) {
 		// Check if else is potentically valid
 		if (!token.compare ("else") && !g_CanElse)
 			ParserError ("else without preceding if");
 		// ============================================================
 		// If
 		if (!token.compare ("if")) {
 			MUST_NOT_TOPLEVEL
-			PushBlockStack ();
+			PushScope ();
 			// Condition
 			MustNext ("(");
 			// Read the expression and write it.
 			// Add a mark - to here temporarily - and add a reference to it.
 			// Upon a closing brace, the mark will be adjusted.
 			unsigned int marknum = w->AddMark ("");
 			// Use DH_IFNOTGOTO - if the expression is not true, we goto the mark
-			// we just defined - and this mark will be at the end of the block.
+			// we just defined - and this mark will be at the end of the scope block.
 			w->Write<word> (DH_IFNOTGOTO);
 			w->AddReference (marknum);
-			// Store it in the block stack
+			// Store it
 			SCOPE(0).mark1 = marknum;
-			SCOPE(0).type = BLOCKTYPE_IF;
+			SCOPE(0).type = SCOPETYPE_IF;
 			continue;
 		}
 		if (!token.compare ("else")) {
 			MUST_NOT_TOPLEVEL
 			MustNext ("{");
-			// Don't use PushBlockStack as that will reset the scope.
+			// Don't use PushScope that will reset the scope.
-			g_BlockStackCursor++;
+			g_ScopeCursor++;
-			if (g_BlockStackCursor >= MAX_STRUCTSTACK)
+			if (g_ScopeCursor >= MAX_STRUCTSTACK)
 				ParserError ("too deep scope");
-			if (SCOPE(0).type != BLOCKTYPE_IF)
+			if (SCOPE(0).type != SCOPETYPE_IF)
 				ParserError ("else without preceding if");
 			// Write down to jump to the end of the else statement
 			// Otherwise we have fall-throughs
 			SCOPE(0).mark2 = w->AddMark ("");
 			w->Write (DH_GOTO);
 			w->AddReference (SCOPE(0).mark2);
 			// Move the ifnot mark here and set type to else
 			w->MoveMark (SCOPE(0).mark1);
-			SCOPE(0).type = BLOCKTYPE_ELSE;
+			SCOPE(0).type = SCOPETYPE_ELSE;
 			continue;
 		}
 		// ============================================================
 		// While
 		if (!token.compare ("while")) {
 			MUST_NOT_TOPLEVEL
-			PushBlockStack ();
+			PushScope ();
 			// While loops need two marks - one at the start of the loop and one at the
 			// end. The condition is checked at the very start of the loop, if it fails,
 			// we use goto to skip to the end of the loop. At the end, we loop back to
 			// the beginning with a go-to statement.
 			w->AddReference (mark2);
 			// Store the needed stuff
 			SCOPE(0).mark1 = mark1;
 			SCOPE(0).mark2 = mark2;
-			SCOPE(0).type = BLOCKTYPE_WHILE;
+			SCOPE(0).type = SCOPETYPE_WHILE;
 			continue;
 		}
 		// ============================================================
 		// For loop
 		if (!token.compare ("for")) {
 			MUST_NOT_TOPLEVEL
-			PushBlockStack ();
+			PushScope ();
 			// Initializer
 			MustNext ("(");
 			MustNext ();
 			DataBuffer* init = ParseStatement (w);
 			// Store the marks and incrementor
 			SCOPE(0).mark1 = mark1;
 			SCOPE(0).mark2 = mark2;
 			SCOPE(0).buffer1 = incr;
-			SCOPE(0).type = BLOCKTYPE_FOR;
+			SCOPE(0).type = SCOPETYPE_FOR;
 			continue;
 		}
 		// ============================================================
 		// Do/while loop
 		if (!token.compare ("do")) {
 			MUST_NOT_TOPLEVEL
-			PushBlockStack ();
+			PushScope ();
 			MustNext ("{");
 			SCOPE(0).mark1 = w->AddMark ("");
-			SCOPE(0).type = BLOCKTYPE_DO;
+			SCOPE(0).type = SCOPETYPE_DO;
 			continue;
 		}
 		// ============================================================
 		// Switch
 			 * casemark3: ...
 			 * mark1: // end mark
 			 */
 			MUST_NOT_TOPLEVEL
-			PushBlockStack ();
+			PushScope ();
 			MustNext ("(");
 			MustNext ();
 			w->WriteBuffer (ParseExpression (TYPE_INT));
 			MustNext (")");
 			MustNext ("{");
-			SCOPE(0).type = BLOCKTYPE_SWITCH;
+			SCOPE(0).type = SCOPETYPE_SWITCH;
 			SCOPE(0).mark1 = w->AddMark (""); // end mark
 			SCOPE(0).buffer1 = NULL; // default header
 			continue;
 		}
 		// ============================================================
 		if (!token.compare ("case")) {
 			// case is only allowed inside switch
-			if (SCOPE(0).type != BLOCKTYPE_SWITCH)
+			if (SCOPE(0).type != SCOPETYPE_SWITCH)
 				ParserError ("case label outside switch");
 			// Get the literal (Zandronum does not support expressions here)
 			MustNumber ();
 			int num = atoi (token.chars ());
 			SCOPE(0).casenumbers[SCOPE(0).casecursor] = num;
 			continue;
 		}
 		if (!token.compare ("default")) {
-			if (SCOPE(0).type != BLOCKTYPE_SWITCH)
+			if (SCOPE(0).type != SCOPETYPE_SWITCH)
 				ParserError ("default label outside switch");
 			if (SCOPE(0).buffer1)
 				ParserError ("multiple default labels in one switch");
 		}
 		// ============================================================
 		// Break statement.
 		if (!token.compare ("break")) {
-			if (!g_BlockStackCursor)
+			if (!g_ScopeCursor)
 				ParserError ("unexpected `break`");
 			w->Write<word> (DH_GOTO);
 			// switch and if use mark1 for the closing point,
 			// for and while use mark2.
 			switch (SCOPE(0).type) {
-			case BLOCKTYPE_IF:
+			case SCOPETYPE_IF:
-			case BLOCKTYPE_SWITCH:
+			case SCOPETYPE_SWITCH:
 				w->AddReference (SCOPE(0).mark1);
 				break;
-			case BLOCKTYPE_FOR:
+			case SCOPETYPE_FOR:
-			case BLOCKTYPE_WHILE:
+			case SCOPETYPE_WHILE:
 				w->AddReference (SCOPE(0).mark2);
 				break;
 			default:
 				ParserError ("unexpected `break`");
 				break;
 		// ============================================================
 		if (!token.compare ("}")) {
 			// Closing brace
 			// If we're in the block stack, we're descending down from it now
-			if (g_BlockStackCursor > 0) {
+			if (g_ScopeCursor > 0) {
 				switch (SCOPE(0).type) {
-				case BLOCKTYPE_IF:
+				case SCOPETYPE_IF:
 					// Adjust the closing mark.
 					w->MoveMark (SCOPE(0).mark1);
 					// We're returning from if, thus else can be next
 					g_CanElse = true;
 					break;
-				case BLOCKTYPE_ELSE:
+				case SCOPETYPE_ELSE:
 					// else instead uses mark1 for itself (so if expression
 					// fails, jump to else), mark2 means end of else
 					w->MoveMark (SCOPE(0).mark2);
 					break;
-				case BLOCKTYPE_FOR:
+				case SCOPETYPE_FOR:
 					// Write the incrementor at the end of the loop block
 					w->WriteBuffer (SCOPE(0).buffer1);
 					// fall-thru
-				case BLOCKTYPE_WHILE:
+				case SCOPETYPE_WHILE:
 					// Write down the instruction to go back to the start of the loop
 					w->Write (DH_GOTO);
 					w->AddReference (SCOPE(0).mark1);
 					// Move the closing mark here since we're at the end of the while loop
 					w->MoveMark (SCOPE(0).mark2);
 					break;
-				case BLOCKTYPE_DO: {
+				case SCOPETYPE_DO: {
 					MustNext ("while");
 					MustNext ("(");
 					MustNext ();
 					DataBuffer* expr = ParseExpression (TYPE_INT);
 					MustNext (")");
 					w->WriteBuffer (expr);
 					w->Write<long> (DH_IFGOTO);
 					w->AddReference (SCOPE(0).mark1);
 					break;
 				}
-				case BLOCKTYPE_SWITCH: {
+				case SCOPETYPE_SWITCH: {
 					// Switch closes. Move down to the record buffer of
 					// the lower block.
 					if (SCOPE(1).casecursor != -1)
 						w->SwitchBuffer = SCOPE(1).casebuffers[SCOPE(1).casecursor];
 					else
 					w->MoveMark (SCOPE(0).mark1);
 				}
 				}
 				// Descend down the stack
-				g_BlockStackCursor--;
+				g_ScopeCursor--;
 				continue;
 			}
 			int dataheader =	(g_CurMode == MODE_EVENT) ? DH_ENDEVENT :
 						(g_CurMode == MODE_MAINLOOP) ? DH_ENDMAINLOOP :
 	}
 	return retbuf;
 }
-void ScriptReader::PushBlockStack () {
+void ScriptReader::PushScope () {
-	g_BlockStackCursor++;
+	g_ScopeCursor++;
-	if (g_BlockStackCursor >= MAX_STRUCTSTACK)
+	if (g_ScopeCursor >= MAX_STRUCTSTACK)
 		ParserError ("too deep scope");
 	BlockInformation* info = &SCOPE(0);
 	info->type = 0;
 	info->mark1 = 0;

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx