botc: comparison parser.cxx

-:3d3f6ed40171
+:a8838b5f1213
 str g_CurState = "";
 bool g_stateSpawnDefined = false;
 bool g_GotMainLoop = false;
 // ============================================================================
-// Main parser
+// 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()) {
+		printf ("BeginParse: token: `%s`\n", token.chars());
 		if (!token.icompare ("state")) {
 			MUST_TOPLEVEL
 			MustString ();
 			MustNext ("{");
 			g_CurMode = MODE_EVENT;
 			w->Write (DH_EVENT);
-			w->Write<byte> (e->number);
+			w->Write<word> (e->number);
 			g_NumEvents++;
 			continue;
 		}
 		if (!token.icompare ("mainloop")) {
 			MustNext (";");
 			continue;
 		}
 		if (!token.compare ("}")) {
+			printf ("parse closing brace\n");
 			// Closing brace
 			int dataheader =	(g_CurMode == MODE_EVENT) ? DH_ENDEVENT :
 						(g_CurMode == MODE_MAINLOOP) ? DH_ENDMAINLOOP :
 						(g_CurMode == MODE_ONENTER) ? DH_ENDONENTER :
 						(g_CurMode == MODE_ONEXIT) ? DH_ENDONEXIT : -1;
 			if (dataheader == -1)
 				ParserError ("unexpected `}`");
 			// Data header must be written before mode is changed because
-			// onenter and mainloop go into buffers, and we want the closing
+			// onenter and mainloop go into special buffers, and we want
-			// data headers into said buffers too.
+			// the closing data headers into said buffers too.
 			w->Write (dataheader);
 			g_CurMode = MODE_TOPLEVEL;
 			if (!PeekNext().compare (";"))
 				MustNext (";");
 			continue;
 		}
+		// If it's a variable, expect assignment.
+		if (ScriptVar* var = FindGlobalVariable (token)) {
+			DataBuffer* b = ParseAssignment (var);
+			printf ("current token after assignment: `%s`\n", token.chars());
+			MustNext (";");
+			w->WriteBuffer (b);
+			delete b;
+			continue;
+		}
 		// If it's not a keyword, parse it as an expression.
+		printf ("token length: %d, first char: %c [%d]\n", token.len(), token.chars()[0], token.chars()[0]);
 		DataBuffer* b = ParseExpression (TYPE_VOID);
 		w->WriteBuffer (b);
 		delete b;
-		printf ("expression done!\n");
+		printf ("expression done! current token is %s\n", token.chars());
-		MustThis (";");
+		MustNext (";");
 	}
 	if (g_CurMode != MODE_TOPLEVEL)
 		ParserError ("script did not end at top level; did you forget a `}`?");
 	// String table
 	w->WriteStringTable ();
 }
 // ============================================================================
-// Parses a given command
+// Parses a command call
 DataBuffer* ScriptReader::ParseCommand (CommandDef* comm) {
 	DataBuffer* r = new DataBuffer(64);
-	// If this was defined at top-level, we stop right at square one!
 	if (g_CurMode == MODE_TOPLEVEL)
-		ParserError ("no commands allowed at top level!");
+		ParserError ("command call at top level");
+	printf ("\n\n\n=====================================\nBEGIN PARSING COMMAND\n");
 	printf ("token: %s\n", token.chars());
 	MustNext ("(");
+	MustNext ();
 	int curarg = 0;
 	while (1) {
+		printf ("at argument %d\n", curarg);
+		printf ("next token: %s\n", token.chars());
 		if (!token.compare (")")) {
 			printf ("closing command with token `%s`\n", token.chars());
 			if (curarg < comm->numargs - 1)
 				ParserError ("too few arguments passed to %s\n", comm->name.chars());
 			break;
 			curarg++;
 		}
-		printf ("prev token: %s\n", token.chars());
-		MustNext ();
-		printf ("next token: %s\n", token.chars());
-		// jump back to start
-		if (!token.compare (")"))
-			continue;
 		if (curarg >= comm->maxargs)
 			ParserError ("too many arguments passed to %s\n", comm->name.chars());
 		r->Merge (ParseExpression (comm->argtypes[curarg]));
+		MustNext ();
+		printf ("after expression, token is `%s`\n", token.chars());
 		if (curarg < comm->numargs - 1) {
 			MustThis (",");
+			MustNext ();
 		} else if (curarg < comm->maxargs - 1) {
 			// Can continue, but can terminate as well.
 			if (!token.compare (")")) {
 				curarg++;
 				break;
-			} else
+			} else {
 				MustThis (",");
+				MustNext ();
+			}
 		}
 		curarg++;
 	}
 	// If the script skipped any optional arguments, fill in defaults.
 	while (curarg < comm->maxargs) {
-		r->Write<byte> (DH_PUSHNUMBER);
+		r->Write<word> (DH_PUSHNUMBER);
-		r->Write<byte> (comm->defvals[curarg]);
+		r->Write<word> (comm->defvals[curarg]);
 		curarg++;
 	}
-	r->Write<byte> (DH_COMMAND);
+	r->Write<word> (DH_COMMAND);
-	r->Write<byte> (comm->number);
+	r->Write<word> (comm->number);
-	r->Write<byte> (comm->maxargs);
+	r->Write<word> (comm->maxargs);
 	printf ("command complete\n");
 	return r;
 }
+// ============================================================================
+// Is the given operator an assignment operator?
 static bool IsAssignmentOperator (int oper) {
 	switch (oper) {
 	case OPER_ASSIGNADD:
 	case OPER_ASSIGNSUB:
 	case OPER_ASSIGNMUL:
 	}
 	return false;
 }
 // ============================================================================
+// Finds an operator's corresponding dataheader
 static long DataHeaderByOperator (ScriptVar* var, int oper) {
 	if (IsAssignmentOperator (oper)) {
 		if (!var)
 			error ("operator %d requires left operand to be a variable\n", oper);
 	error ("DataHeaderByOperator: couldn't find dataheader for operator %d!\n", oper);
 	return 0;
 }
 // ============================================================================
-// Parses an expression
+// Parses an expression, potentially recursively
 DataBuffer* ScriptReader::ParseExpression (int reqtype) {
 	printf ("begin parsing expression. this token is `%s`, next token is `%s`\n",
 		token.chars(), PeekNext().chars());
 	DataBuffer* retbuf = new DataBuffer (64);
 	DataBuffer* lb = NULL;
+	// If it's a variable, note it down - we need to do special checks with it later.
 	ScriptVar* var = FindGlobalVariable (token);
-	if (var) {
-		MustNext ();
+	lb = ParseExprValue (reqtype);
-		if (g_CurMode == MODE_TOPLEVEL) // TODO: lift this restriction
-			ParserError ("can't alter variables at top level");
-		reqtype = TYPE_INT;
-	} else
-		lb = ParseExprValue (reqtype);
 	printf ("done\n");
 	// Get an operator
 	printf ("parse operator at token %s\n", token.chars());
-	int oper = ParseOperator ();
+	int oper = ParseOperator (true);
+	printf ("operator parsed: token is now %s\n", token.chars());
 	printf ("got %d\n", oper);
 	// No operator found - stop here.
 	if (oper == -1) {
 		retbuf->Merge (lb);
 		printf ("expression complete without operator, stopping at `%s`\n", token.chars());
 		return retbuf;
 	}
+	// We peeked the operator, move forward now
+	MustNext();
+	// Can't be an assignement operator, those belong in assignments.
+	if (IsAssignmentOperator (oper))
+		ParserError ("assignment operator inside expressions");
 	// Parse the right operand,
 	printf ("parse right operand\n");
 	MustNext ();
 	DataBuffer* rb = ParseExprValue (reqtype);
 	printf ("done\n");
+	retbuf->Merge (rb);
 	retbuf->Merge (lb);
-	retbuf->Merge (rb);
 	long dh = DataHeaderByOperator (var, oper);
-	retbuf->Write<byte> (dh);
+	retbuf->Write<word> (dh);
-	if (IsAssignmentOperator (oper))
-		retbuf->Write<byte> (var->index);
 	printf ("expression complete\n");
 	return retbuf;
 }
 // ============================================================================
-// Parsess an operator from tokens and returns an identifier.
+// Parses an operator string. Returns the operator number code.
-int ScriptReader::ParseOperator () {
+int ScriptReader::ParseOperator (bool peek) {
 	str oper;
-	oper += PeekNext ();
+	if (peek)
+		oper += PeekNext ();
+	else
+		oper += token;
 	// Check one-char operators
 	int o =	!oper.compare ("=") ? OPER_ASSIGN :
 		!oper.compare ("+") ? OPER_ADD :
 		!oper.compare ("-") ? OPER_SUBTRACT :
 		!oper.compare ("/") ? OPER_DIVIDE :
 		!oper.compare ("%") ? OPER_MODULUS :
 		-1;
 	if (o != -1) {
-		MustNext ();
 		return o;
 	}
 	// Two-char operators
-	MustNext ();
+	oper += PeekNext (peek ? 1 : 0);
-	oper += PeekNext (1);
 	o =	!oper.compare ("+=") ? OPER_ASSIGNADD :
 		!oper.compare ("-=") ? OPER_ASSIGNSUB :
 		!oper.compare ("*=") ? OPER_ASSIGNMUL :
 		!oper.compare ("/=") ? OPER_ASSIGNDIV :
 		!oper.compare ("%=") ? OPER_ASSIGNMOD :
 		-1;
-	if (o != -1) {
+	if (o != -1)
 		MustNext ();
-		MustNext ();
-	}
 	return o;
 }
 // ============================================================================
 		delete b;
 		// Command
 		if (reqtype && comm->returnvalue != reqtype)
 			ParserError ("%s returns an incompatible data type", comm->name.chars());
-		return ParseCommand (comm);
+		b = ParseCommand (comm);
 	} else if ((g = FindGlobalVariable (token)) && reqtype != TYPE_STRING) {
 		printf ("value is a global var\n");
 		// Global variable
-		b->Write<byte> (DH_PUSHGLOBALVAR);
+		b->Write<word> (DH_PUSHGLOBALVAR);
-		b->Write<byte> (g->index);
+		b->Write<word> (g->index);
 	} else {
 		printf ("value is a literal\n");
 		// If nothing else, check for literal
 		switch (reqtype) {
 		case TYPE_VOID:
 			ParserError ("bad syntax");
 			break;
 		case TYPE_INT: {
-			printf ("value is an integer literal\n");
-			/* if (!token.isnumber ())
-				ParserError ("expected an integer, got `%s`", token.chars());
-			*/
 			MustNumber (true);
-			printf ("literal is `%s` = %d\n", token.chars(), atoi (token.chars()));
 			// All values are written unsigned - thus we need to write the value's
 			// absolute value, followed by an unary minus if it was negative.
-			b->Write<byte> (DH_PUSHNUMBER);
+			b->Write<word> (DH_PUSHNUMBER);
 			long v = atoi (token.chars ());
-			b->Write<byte> (static_cast<byte> (abs (v)));
+			b->Write<word> (static_cast<word> (abs (v)));
-			if (v < 0) {
+			if (v < 0)
-				printf ("%ld is negative, write abs value %d and unary minus\n", v, abs(v));
+				b->Write<word> (DH_UNARYMINUS);
-				b->Write<byte> (DH_UNARYMINUS);
-			}
 			break;
 		}
 		case TYPE_STRING:
 			// PushToStringTable either returns the string index of the
 			// string if it finds it in the table, or writes it to the
 			// table and returns it index if it doesn't find it there.
 			printf ("value is a string literal\n");
 			MustString (true);
-			b->Write<byte> (DH_PUSHSTRINGINDEX);
+			b->Write<word> (DH_PUSHSTRINGINDEX);
-			b->Write<byte> (PushToStringTable (token.chars()));
+			b->Write<word> (PushToStringTable (token.chars()));
 			break;
 		}
 	}
+	printf ("value parsed: current token is `%s`\n", token.chars());
 	return b;
 }
+// ============================================================================
+// Parses an assignment. An assignment starts with a variable name, followed
+// by an assignment operator, followed by an expression value. Expects current
+// token to be the name of the variable, and expects the variable to be given.
+DataBuffer* ScriptReader::ParseAssignment (ScriptVar* var) {
+	printf ("ASSIGNMENT: this token is `%s`, next token is `%s`\n",
+		token.chars(), PeekNext().chars());
+	// Get an operator
+	printf ("parse assignment operator at token %s\n", token.chars());
+	MustNext ();
+	int oper = ParseOperator ();
+	if (!IsAssignmentOperator (oper))
+		ParserError ("expected assignment operator");
+	printf ("got %d\n", oper);
+	if (g_CurMode == MODE_TOPLEVEL) // TODO: lift this restriction
+		ParserError ("can't alter variables at top level");
+	// Parse the right operand,
+	printf ("parse right operand\n");
+	MustNext ();
+	DataBuffer* retbuf = ParseExprValue (TYPE_INT);
+	long dh = DataHeaderByOperator (var, oper);
+	retbuf->Write<word> (dh);
+	retbuf->Write<word> (var->index);
+	printf ("assignment complete\n");
+	return retbuf;
+}

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx