botc: comparison parser.cxx

-:ec04357f5bb9
+:4fc1ec88aa41
 bool g_GotMainLoop = false;
 unsigned int g_ScopeCursor = 0;
 DataBuffer* g_IfExpression = NULL;
 bool g_CanElse = false;
 str* g_UndefinedLabels[MAX_MARKS];
+bool g_Neurosphere = false; // neurosphere-compat
 // ============================================================================
 // 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.
 	for (int i = 0; i < MAX_MARKS; i++)
 		g_UndefinedLabels[i] = NULL;
 	while (Next()) {
 		// Check if else is potentically valid
-		if (!token.compare ("else") && !g_CanElse)
+		if (token == "else" && !g_CanElse)
 			ParserError ("else without preceding if");
-		if (token.compare ("else") != 0)
+		if (token != "else")
 			g_CanElse = false;
 		// ============================================================
-		if (!token.compare ("state")) {
+		if (token == "state") {
 			MUST_TOPLEVEL
 			MustString ();
 			// State name must be a word.
 			g_GotMainLoop = false;
 			continue;
 		}
 		// ============================================================
-		if (!token.compare ("event")) {
+		if (token == "event") {
 			MUST_TOPLEVEL
 			// Event definition
 			MustString ();
 			g_NumEvents++;
 			continue;
 		}
 		// ============================================================
-		if (!token.compare ("mainloop")) {
+		if (token == "mainloop") {
 			MUST_TOPLEVEL
 			MustNext ("{");
 			// Mode must be set before dataheader is written here!
 			g_CurMode = MODE_MAINLOOP;
 			w->Write (DH_MAINLOOP);
 			continue;
 		}
 		// ============================================================
-		if (!token.compare ("onenter") || !token.compare ("onexit")) {
+		if (token == "onenter" || token == "onexit") {
 			MUST_TOPLEVEL
-			bool onenter = !token.compare ("onenter");
+			bool onenter = token == "onenter";
 			MustNext ("{");
 			// Mode must be set before dataheader is written here,
 			// because onenter goes to a separate buffer.
 			g_CurMode = onenter ? MODE_ONENTER : MODE_ONEXIT;
 			w->Write (onenter ? DH_ONENTER : DH_ONEXIT);
 			continue;
 		}
 		// ============================================================
-		if (!token.compare ("var")) {
+		if (token == "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;
 		}
 		// ============================================================
 		// Goto
-		if (!token.compare ("goto")) {
+		if (token == "goto") {
 			MUST_NOT_TOPLEVEL
 			// Get the name of the label
 			MustNext ();
 			continue;
 		}
 		// ============================================================
 		// If
-		if (!token.compare ("if")) {
+		if (token == "if") {
 			MUST_NOT_TOPLEVEL
 			PushScope ();
 			// Condition
 			MustNext ("(");
 			SCOPE(0).mark1 = marknum;
 			SCOPE(0).type = SCOPETYPE_IF;
 			continue;
 		}
-		if (!token.compare ("else")) {
+		if (token == "else") {
 			MUST_NOT_TOPLEVEL
 			MustNext ("{");
 			// Don't use PushScope that will reset the scope.
 			g_ScopeCursor++;
 			continue;
 		}
 		// ============================================================
 		// While
-		if (!token.compare ("while")) {
+		if (token == "while") {
 			MUST_NOT_TOPLEVEL
 			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,
 			continue;
 		}
 		// ============================================================
 		// For loop
-		if (!token.compare ("for")) {
+		if (token == "for") {
 			MUST_NOT_TOPLEVEL
 			PushScope ();
 			// Initializer
 			MustNext ("(");
 			continue;
 		}
 		// ============================================================
 		// Do/while loop
-		if (!token.compare ("do")) {
+		if (token == "do") {
 			MUST_NOT_TOPLEVEL
 			PushScope ();
 			MustNext ("{");
 			SCOPE(0).mark1 = w->AddMark ("");
 			SCOPE(0).type = SCOPETYPE_DO;
 			continue;
 		}
 		// ============================================================
 		// Switch
-		if (!token.compare ("switch")) {
+		if (token == "switch") {
 			/* This goes a bit tricky. switch is structured in the
 			 * bytecode followingly:
 			 * (expression)
 			 * case a: goto casemark1
 			 * case b: goto casemark2
 			SCOPE(0).buffer1 = NULL; // default header
 			continue;
 		}
 		// ============================================================
-		if (!token.compare ("case")) {
+		if (token == "case") {
 			// case is only allowed inside switch
 			if (SCOPE(0).type != SCOPETYPE_SWITCH)
 				ParserError ("case label outside switch");
 			// Get the literal (Zandronum does not support expressions here)
 			AddSwitchCase (w, NULL);
 			SCOPE(0).casenumbers[SCOPE(0).casecursor] = num;
 			continue;
 		}
-		if (!token.compare ("default")) {
+		if (token == "default") {
 			if (SCOPE(0).type != SCOPETYPE_SWITCH)
 				ParserError ("default label outside switch");
 			if (SCOPE(0).buffer1)
 				ParserError ("multiple default labels in one switch");
 			continue;
 		}
 		// ============================================================
 		// Break statement.
-		if (!token.compare ("break")) {
+		if (token == "break") {
 			if (!g_ScopeCursor)
 				ParserError ("unexpected `break`");
 			w->Write<word> (DH_GOTO);
 			continue;
 		}
 		// ============================================================
 		// Continue
-		if (!token.compare ("continue")) {
+		if (token == "continue") {
 			MustNext (";");
 			int curs;
 			bool found = false;
 				case SCOPETYPE_WHILE:
 				case SCOPETYPE_DO:
 					w->Write<word> (DH_GOTO);
 					w->AddReference (scopestack[curs].mark1);
 					found = true;
+					break;
+				default:
 					break;
 				}
 			}
 			// No loop blocks
 						w->WriteBuffer (SCOPE(0).casebuffers[u]);
 					}
 					// Move the closing mark here
 					w->MoveMark (SCOPE(0).mark1);
+					break;
 				}
+				case SCOPETYPE_UNKNOWN:
+					break;
 				}
 				// Descend down the stack
 				g_ScopeCursor--;
 				continue;
 			if (!PeekNext().compare (";"))
 				MustNext (";");
 			continue;
 		}
-		// ============================================================
+		// Check if it's a command
-		// If nothing else, parse it as a statement (which is either
+		CommandDef* comm = FindCommand (token);
-		// assignment or expression)
+		if (comm) {
+			w->GetCurrentBuffer()->Merge (ParseCommand (comm));
+			MustNext (";");
+			continue;
+		}
+		// ============================================================
+		// If nothing else, parse it as a statement
 		DataBuffer* b = ParseStatement (w);
 		w->WriteBuffer (b);
 		MustNext (";");
 	}
+	// ===============================================================================
+	// Script file ended. Do some last checks and write the last things to main buffer
 	if (g_CurMode != MODE_TOPLEVEL)
 		ParserError ("script did not end at top level; did you forget a `}`?");
 	// stateSpawn must be defined!
 	if (!g_stateSpawnDefined)
 			MustNext ();
 			DataBuffer* tb = ParseExprValue (reqtype);
 			// It also is handled differently: there isn't a dataheader for ternary
 			// operator. Instead, we abuse PUSHNUMBER and IFNOTGOTO for this.
+			// Behold, big block of writing madness! :P
 			int mark1 = retbuf->AddMark (""); // start of "else" case
 			int mark2 = retbuf->AddMark (""); // end of expression
-			retbuf->Write<word> (DH_IFNOTGOTO);
+			retbuf->Write<word> (DH_IFNOTGOTO); // if the first operand (condition)
-			retbuf->AddMarkReference (mark1);
+			retbuf->AddMarkReference (mark1); // didn't eval true, jump into mark1
-			retbuf->Merge (rb);
+			retbuf->Merge (rb); // otherwise, perform second operand (true case)
-			retbuf->Write<word> (DH_GOTO);
+			retbuf->Write<word> (DH_GOTO); // afterwards, jump to the end, which is
-			retbuf->AddMarkReference (mark2);
+			retbuf->AddMarkReference (mark2); // marked by mark2.
-			retbuf->MoveMark (mark1); // start of "else" case
+			retbuf->MoveMark (mark1); // move mark1 at the end of the true case
-			retbuf->Merge (tb);
+			retbuf->Merge (tb); // perform third operand (false case)
-			retbuf->Write<word> (DH_GOTO);
+			retbuf->MoveMark (mark2); // move the ending mark2 here
-			retbuf->AddMarkReference (mark2);
-			retbuf->MoveMark (mark2); // move endmark to end
 		} else {
 			// Write to buffer
 			retbuf->Merge (rb);
 			retbuf->Write<word> (DataHeaderByOperator (NULL, oper));
 		}
 	g_ScopeCursor++;
 	if (g_ScopeCursor >= MAX_SCOPE)
 		ParserError ("too deep scope");
 	ScopeInfo* info = &SCOPE(0);
-	info->type = 0;
+	info->type = SCOPETYPE_UNKNOWN;
 	info->mark1 = 0;
 	info->mark2 = 0;
 	info->buffer1 = NULL;
 	info->casecursor = -1;
 	for (int i = 0; i < MAX_CASE; i++) {

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx