botc: comparison parser.cxx

-:8e2f7a031410
+:2e333a3ca49a
 // ============================================================================
 // 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) {
+void ScriptReader::ParseBotScript (ObjWriter* w) {
 	while (Next()) {
 		// ============================================================
-		if (!token.icompare ("state")) {
+		if (!token.compare ("state")) {
 			MUST_TOPLEVEL
 			MustString ();
 			// State name must be a word.
 			g_GotMainLoop = false;
 			continue;
 		}
 		// ============================================================
-		if (!token.icompare ("event")) {
+		if (!token.compare ("event")) {
 			MUST_TOPLEVEL
 			// Event definition
 			MustString ();
 			g_NumEvents++;
 			continue;
 		}
 		// ============================================================
-		if (!token.icompare ("mainloop")) {
+		if (!token.compare ("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")) {
+		if (!token.compare ("onenter") || !token.compare ("onexit")) {
 			MUST_TOPLEVEL
 			bool onenter = !token.compare ("onenter");
 			MustNext ("{");
 			// Mode must be set before dataheader is written here,
 			MustNext (";");
 			continue;
 		}
 		// ============================================================
-		// Label
-		if (!PeekNext().compare (":")) {
-			MUST_NOT_TOPLEVEL
-			if (IsKeyword (token))
-				ParserError ("label name `%s` conflicts with keyword\n", token.chars());
-			if (FindCommand (token))
-				ParserError ("label name `%s` conflicts with command name\n", token.chars());
-			if (FindGlobalVariable (token))
-				ParserError ("label name `%s` conflicts with variable\n", token.chars());
-			w->AddMark (token);
-			MustNext (":");
-			continue;
-		}
-		// ============================================================
 		// Goto
-		if (!token.icompare ("goto")) {
+		if (!token.compare ("goto")) {
 			MUST_NOT_TOPLEVEL
 			// Get the name of the label
 			MustNext ();
 			continue;
 		}
 		// ============================================================
 		// If
-		if (!token.icompare ("if")) {
+		if (!token.compare ("if")) {
 			MUST_NOT_TOPLEVEL
 			PushBlockStack ();
 			// Condition
 			MustNext ("(");
 			// Condition
 			MustNext ("(");
 			MustNext ();
 			DataBuffer* expr = ParseExpression (TYPE_INT);
 			MustNext (")");
 			MustNext ("{");
 			// Write condition
 			w->WriteBuffer (expr);
 			continue;
 		}
 		// ============================================================
 		// For loop
-		if (!token.icompare ("for")) {
+		if (!token.compare ("for")) {
 			MUST_NOT_TOPLEVEL
 			PushBlockStack ();
 			// Initializer
 			MustNext ("(");
 			continue;
 		}
 		// ============================================================
 		// Do/while loop
-		if (!token.icompare ("do")) {
+		if (!token.compare ("do")) {
 			MUST_NOT_TOPLEVEL
 			PushBlockStack ();
 			MustNext ("{");
 			blockstack[g_BlockStackCursor].mark1 = w->AddMark ("");
 			blockstack[g_BlockStackCursor].type = BLOCKTYPE_DO;
 			continue;
 		}
 		// ============================================================
 		// Switch
-		if (!token.icompare ("switch")) {
+		if (!token.compare ("switch")) {
 			/* This goes a bit tricky. switch is structured in the
 			 * bytecode followingly:
 			 * (expression)
 			 * case a: goto casemark1
 			 * case b: goto casemark2
 			w->WriteBuffer (ParseExpression (TYPE_INT));
 			MustNext (")");
 			MustNext ("{");
 			blockstack[g_BlockStackCursor].type = BLOCKTYPE_SWITCH;
 			blockstack[g_BlockStackCursor].mark1 = w->AddMark (""); // end mark
-			continue;
+			blockstack[g_BlockStackCursor].buffer1 = NULL; // default header
-		}
+			continue;
+		}
-		// ============================================================
-		if (!token.icompare ("case")) {
+		// ============================================================
+		if (!token.compare ("case")) {
 			// case is only allowed inside switch
-			if (g_BlockStackCursor <= 0 || blockstack[g_BlockStackCursor].type != BLOCKTYPE_SWITCH)
-				ParserError ("`case` outside switch");
 			BlockInformation* info = &blockstack[g_BlockStackCursor];
-			info->casecursor++;
+			if (info->type != BLOCKTYPE_SWITCH)
-			if (info->casecursor >= MAX_CASE)
+				ParserError ("case label outside switch");
-				ParserError ("too many `case` statements in one switch");
 			// Get the literal (Zandronum does not support expressions here)
 			MustNumber ();
 			int num = atoi (token.chars ());
 			MustNext (":");
-			// Init a mark for the case buffer
+			for (int i = 0; i < MAX_CASE; i++)
-			int m = w->AddMark ("");
+				if (info->casenumbers[i] == num)
-			info->casemarks[info->casecursor] = m;
+					ParserError ("multiple case %d labels in one switch", num);
 			// Write down the expression and case-go-to. This builds
 			// the case tree. The closing event will write the actual
 			// blocks and move the marks appropriately.
-			//
+			//	AddSwitchCase will add the reference to the mark
-			// NULL the switch buffer for the case-go-to statement,
+			// for the case block that this heralds, and takes care
+			// of buffering setup and stuff like that.
+			//	NULL the switch buffer for the case-go-to statement,
 			// we want it all under the switch, not into the case-buffers.
 			w->SwitchBuffer = NULL;
 			w->Write<word> (DH_CASEGOTO);
 			w->Write<word> (num);
-			w->AddReference (m);
+			AddSwitchCase (w, NULL);
+			info->casenumbers[info->casecursor] = num;
-			// Init a buffer for the case block, tell the object
+			continue;
-			// writer to record all written data to it.
+		}
-			info->casebuffers[info->casecursor] = w->SwitchBuffer = new DataBuffer;
+		if (!token.compare ("default")) {
+			BlockInformation* info = &blockstack[g_BlockStackCursor];
+			if (info->type != BLOCKTYPE_SWITCH)
+				ParserError ("default label outside switch");
+			if (info->buffer1)
+				ParserError ("multiple default labels in one switch");
+			MustNext (":");
+			// The default header is buffered into buffer1, since
+			// it has to be the last of the case headers
+			//
+			// Since the expression is pushed into the switch
+			// and is only popped when case succeeds, we have
+			// to pop it with DH_DROP manually if we end up in
+			// a default.
+			DataBuffer* b = new DataBuffer;
+			info->buffer1 = b;
+			b->Write<word> (DH_DROP);
+			b->Write<word> (DH_GOTO);
+			AddSwitchCase (w, b);
 			continue;
 		}
 		// ============================================================
 		// Break statement.
-		if (!token.icompare ("break")) {
+		if (!token.compare ("break")) {
 			if (!g_BlockStackCursor)
 				ParserError ("unexpected `break`");
 			BlockInformation* info = &blockstack[g_BlockStackCursor];
 				ParserError ("unexpected `break`");
 				break;
 			}
 			MustNext (";");
+			continue;
+		}
+		// ============================================================
+		// Label
+		if (!PeekNext().compare (":")) {
+			MUST_NOT_TOPLEVEL
+			if (IsKeyword (token))
+				ParserError ("label name `%s` conflicts with keyword\n", token.chars());
+			if (FindCommand (token))
+				ParserError ("label name `%s` conflicts with command name\n", token.chars());
+			if (FindGlobalVariable (token))
+				ParserError ("label name `%s` conflicts with variable\n", token.chars());
+			w->AddMark (token);
+			MustNext (":");
 			continue;
 		}
 		// ============================================================
 		if (!token.compare ("}")) {
 					w->WriteBuffer (expr);
 					w->Write<long> (DH_IFGOTO);
 					w->AddReference (info->mark1);
 					break;
 				}
 				case BLOCKTYPE_SWITCH: {
 					// Switch closes. Move down to the record buffer of
 					// the lower block.
 					BlockInformation* previnfo = &blockstack[g_BlockStackCursor - 1];
 					if (previnfo->casecursor != -1)
 						w->SwitchBuffer = previnfo->casebuffers[previnfo->casecursor];
 					else
 						w->SwitchBuffer = NULL;
+					// If there was a default in the switch, write its header down now.
+					// If not, write instruction to jump to the end of switch after
+					// the headers (thus won't fall-through if no case matched)
+					if (info->buffer1)
+						w->WriteBuffer (info->buffer1);
+					else {
+						w->Write<word> (DH_DROP);
+						w->Write<word> (DH_GOTO);
+						w->AddReference (info->mark1);
+					}
 					// Go through all of the buffers we
 					// recorded down and write them.
 					for (unsigned int u = 0; u < MAX_CASE; u++) {
 						if (!info->casebuffers[u])
 	info->buffer1 = NULL;
 	info->casecursor = -1;
 	for (int i = 0; i < MAX_CASE; i++) {
 		info->casemarks[i] = MAX_MARKS;
 		info->casebuffers[i] = NULL;
+		info->casenumbers[i] = -1;
 	}
 }
 DataBuffer* ScriptReader::ParseStatement (ObjWriter* w) {
 	// If it's a variable, expect assignment.
 	// If it's not a keyword, parse it as an expression.
 	DataBuffer* b = ParseExpression (TYPE_VOID);
 	return b;
 }
+void ScriptReader::AddSwitchCase (ObjWriter* w, DataBuffer* b) {
+	BlockInformation* info = &blockstack[g_BlockStackCursor];
+	info->casecursor++;
+	if (info->casecursor >= MAX_CASE)
+		ParserError ("too many cases in one switch");
+	// Init a mark for the case buffer
+	int m = w->AddMark ("");
+	info->casemarks[info->casecursor] = m;
+	// Add a reference to the mark. "case" and "default" both
+	// add the necessary bytecode before the reference.
+	if (b)
+		b->AddMarkReference (m);
+	else
+		w->AddReference (m);
+	// Init a buffer for the case block and tell the object
+	// writer to record all written data to it.
+	info->casebuffers[info->casecursor] = w->SwitchBuffer = new DataBuffer;
+}

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx