botc: comparison src/Parser.cc

-:3384d7aa036a
+:49e38433b9fd
 	mOnEnterBuffer = new DataBuffer;
 	mMainLoopBuffer = new DataBuffer;
 	mCurrentMode = ETopLevelMode;
 	mNumStates = 0;
 	mNumEvents = 0;
-	mScopeCursor = 0;
+	mScopeCursor = -1;
 	mStateSpawnDefined = false;
 	mGotMainLoop = false;
 	mIfExpression = null;
 	mCanElse = false;
+	PushScope();
-	// Zero the entire block stack first
-	// TODO: this shouldn't be necessary
-	for (int i = 0; i < MAX_SCOPE; i++)
-		ZERO (mScopeStack[i]);
 	while (mLexer->GetNext())
 	{
 		// Check if else is potentically valid
 		if (TokenIs (tkElse) && mCanElse == false)
 //
 void BotscriptParser::ParseElse()
 {
 	CheckNotToplevel();
 	mLexer->MustGetNext (tkBraceStart);
+	PushScope (eNoReset);
-	// Don't use PushScope as it resets the scope
-	mScopeCursor++;
-	if (mScopeCursor >= MAX_SCOPE)
-		Error ("too deep scope");
 	if (SCOPE (0).type != eIfScope)
 		Error ("else without preceding if");
 	// write down to jump to the end of the else statement
 {
 	// case is only allowed inside switch
 	if (SCOPE (0).type != eSwitchScope)
 		Error ("case label outside switch");
-	// Get the literal (Zandronum does not support expressions here)
+	// Get a literal value for the case block. Zandronum does not support
+	// expressions here.
 	mLexer->MustGetNext (tkNumber);
 	int num = mLexer->GetToken()->text.ToLong();
 	mLexer->MustGetNext (tkColon);
-	for (int i = 0; i < MAX_CASE; i++)
+	for (const CaseInfo& info : SCOPE(0).cases)
-		if (SCOPE (0).casenumbers[i] == num)
+		if (info.number == num)
-			Error ("multiple case %d labels in one switch", num);
+			Error ("multiple case %1 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.
 	//
 	// we want it all under the switch, not into the case-buffers.
 	mSwitchBuffer = null;
 	buffer()->WriteDWord (dhCaseGoto);
 	buffer()->WriteDWord (num);
 	AddSwitchCase (null);
-	SCOPE (0).casenumbers[SCOPE (0).casecursor] = num;
+	SCOPE (0).casecursor->number = num;
 }
 // ============================================================================
 //
 void BotscriptParser::ParseSwitchDefault()
 {
 	if (SCOPE (0).type != eSwitchScope)
 		Error ("default label outside switch");
-	if (SCOPE (0).buffer1)
+	if (SCOPE (0).buffer1 != null)
 		Error ("multiple default labels in one switch");
 	mLexer->MustGetNext (tkColon);
 	// The default header is buffered into buffer1, since
 	//
 	// Since the expression is pushed into the switch
 	// and is only popped when case succeeds, we have
 	// to pop it with dhDrop manually if we end up in
 	// a default.
-	DataBuffer* b = new DataBuffer;
+	DataBuffer* buf = new DataBuffer;
-	SCOPE (0).buffer1 = b;
+	SCOPE (0).buffer1 = buf;
-	b->WriteDWord (dhDrop);
+	buf->WriteDWord (dhDrop);
-	b->WriteDWord (dhGoto);
+	buf->WriteDWord (dhGoto);
-	AddSwitchCase (b);
+	AddSwitchCase (buf);
 }
 // ============================================================================
 //
 void BotscriptParser::ParseBreak()
 			case eSwitchScope:
 			{
 				// Switch closes. Move down to the record buffer of
 				// the lower block.
-				if (SCOPE (1).casecursor != -1)
+				if (SCOPE (1).casecursor != SCOPE (1).cases.begin() - 1)
-					mSwitchBuffer = SCOPE (1).casebuffers[SCOPE (1).casecursor];
+					mSwitchBuffer = SCOPE (1).casecursor->data;
 				else
 					mSwitchBuffer = 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
 					buffer()->AddReference (SCOPE (0).mark1);
 				}
 				// Go through all of the buffers we
 				// recorded down and write them.
-				for (int u = 0; u < MAX_CASE; u++)
+				for (CaseInfo& info : SCOPE (0).cases)
 				{
-					if (SCOPE (0).casebuffers[u] == null)
+					buffer()->AdjustMark (info.mark);
-						continue;
+					buffer()->MergeAndDestroy (info.data);
-					buffer()->AdjustMark (SCOPE (0).casemarks[u]);
-					buffer()->MergeAndDestroy (SCOPE (0).casebuffers[u]);
 				}
 				// Move the closing mark here
 				buffer()->AdjustMark (SCOPE (0).mark1);
 				break;
 	return retbuf;
 }
 // ============================================================================
 //
-void BotscriptParser::PushScope()
+void BotscriptParser::PushScope (EReset reset)
 {
 	mScopeCursor++;
-	if (mScopeCursor >= MAX_SCOPE)
+	Print ("%1 <-> %2\n", mScopeStack.Size(), mScopeCursor + 1);
-		Error ("too deep scope");
+	if (mScopeStack.Size() < mScopeCursor + 1)
-	ScopeInfo* info = &SCOPE (0);
+	{
-	info->type = eUnknownScope;
+		Print ("Adding a scope\n");
-	info->mark1 = null;
+		ScopeInfo newscope;
-	info->mark2 = null;
+		mScopeStack << newscope;
-	info->buffer1 = null;
+		reset = eResetScope;
-	info->casecursor = -1;
+	}
-	for (int i = 0; i < MAX_CASE; i++)
+	if (reset == eResetScope)
 	{
-		info->casemarks[i] = null;
+		ScopeInfo* info = &SCOPE (0);
-		info->casebuffers[i] = null;
+		info->type = eUnknownScope;
-		info->casenumbers[i] = -1;
+		info->mark1 = null;
+		info->mark2 = null;
+		info->buffer1 = null;
+		info->cases.Clear();
+		info->casecursor = info->cases.begin() - 1;
 	}
 }
 // ============================================================================
 //
 	return null;
 }
 // ============================================================================
 //
-void BotscriptParser::AddSwitchCase (DataBuffer* b)
+void BotscriptParser::AddSwitchCase (DataBuffer* casebuffer)
 {
 	ScopeInfo* info = &SCOPE (0);
+	CaseInfo casedata;
-	info->casecursor++;
-	if (info->casecursor >= MAX_CASE)
-		Error ("too many cases in one switch");
 	// Init a mark for the case buffer
 	ByteMark* casemark = buffer()->AddMark ("");
-	info->casemarks[info->casecursor] = casemark;
+	casedata.mark = casemark;
 	// Add a reference to the mark. "case" and "default" both
 	// add the necessary bytecode before the reference.
-	if (b)
+	if (casebuffer != null)
-		b->AddReference (casemark);
+		casebuffer->AddReference (casemark);
 	else
 		buffer()->AddReference (casemark);
 	// Init a buffer for the case block and tell the object
 	// writer to record all written data to it.
-	info->casebuffers[info->casecursor] = mSwitchBuffer = new DataBuffer;
+	casedata.data = mSwitchBuffer = new DataBuffer;
+	SCOPE(0).cases << casedata;
+	info->casecursor++;
 }
 // ============================================================================
 //
 ConstantInfo* BotscriptParser::FindConstant (const String& tok)
 	// First, resolve references
 	for (MarkReference* ref : mMainBuffer->GetReferences())
 	{
 		// Substitute the placeholder with the mark position
-		for (int v = 0; v < 4; v++)
+		for (int i = 0; i < 4; ++i)
-			mMainBuffer->GetBuffer()[ref->pos + v] = ((ref->target->pos) << (8 * v)) & 0xFF;
+			mMainBuffer->GetBuffer()[ref->pos + i] = (ref->target->pos >> (8 * i)) & 0xFF;
 		Print ("reference at %1 resolved to mark at %2\n", ref->pos, ref->target->pos);
 	}
 	// Then, dump the main buffer to the file

Mercurial > botc / file comparison

comparison: src/Parser.cc

src/Parser.cc