botc: comparison parser.cxx

-:0a202714eea4
+:588cc27e84bb
 #include "scriptreader.h"
 #include "events.h"
 #include "commands.h"
 #include "stringtable.h"
 #include "variables.h"
+#include "array.h"
 #define MUST_TOPLEVEL if (g_CurMode != MODE_TOPLEVEL) \
 	ParserError ("%s-statements may only be defined at top level!", token.chars());
 #define MUST_NOT_TOPLEVEL if (g_CurMode == MODE_TOPLEVEL) \
 unsigned int g_ScopeCursor = 0;
 DataBuffer* g_IfExpression = NULL;
 bool g_CanElse = false;
 str* g_UndefinedLabels[MAX_MARKS];
 bool g_Neurosphere = false; // neurosphere-compat
+array<constinfo_t> g_ConstInfo;
 // ============================================================================
 // 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.
 		if (token == "else") {
 			MUST_NOT_TOPLEVEL
 			MustNext ("{");
-			// Don't use PushScope that will reset the scope.
+			// Don't use PushScope as it resets the scope
 			g_ScopeCursor++;
 			if (g_ScopeCursor >= MAX_SCOPE)
 				ParserError ("too deep scope");
 			if (SCOPE(0).type != SCOPETYPE_IF)
 			// Not found in unmarked lists, define it now
 			if (mark == -1)
 				w->AddMark (token);
 			MustNext (":");
+			continue;
+		}
+		// ============================================================
+		if (token == "const") {
+			constinfo_t info;
+			// Get the type
+			MustNext ();
+			info.type = GetTypeByName (token);
+			if (info.type == TYPE_UNKNOWN || info.type == TYPE_VOID)
+				ParserError ("unknown type `%s` for constant", (char*)token);
+			MustNext ();
+			info.name = token;
+			MustNext ("=");
+			switch (info.type) {
+			case TYPE_BOOL:
+			case TYPE_INT:
+				MustNumber (false);
+				info.val = token;
+				break;
+			case TYPE_STRING:
+				MustString ();
+				info.val = token;
+				break;
+			case TYPE_FLOAT:
+				MustNext ();
+				info.val = ParseFloat ();
+				break;
+			case TYPE_UNKNOWN:
+			case TYPE_VOID:
+				break;
+			}
+			g_ConstInfo << info;
+			MustNext (";");
 			continue;
 		}
 		// ============================================================
 		if (token == "}") {
 	return 0;
 }
 // ============================================================================
 // Parses an expression, potentially recursively
-DataBuffer* ScriptReader::ParseExpression (int reqtype) {
+DataBuffer* ScriptReader::ParseExpression (type_e reqtype) {
 	DataBuffer* retbuf = new DataBuffer (64);
 	// Parse first operand
 	retbuf->Merge (ParseExprValue (reqtype));
 	if (peek)
 		oper += PeekNext ();
 	else
 		oper += token;
+	if (-oper == "strlen")
+		return OPER_STRLEN;
 	// Check one-char operators
 	bool equalsnext = ISNEXT ("=");
 	int o =	(oper == "=" && !equalsnext) ? OPER_ASSIGN :
 		(oper == ">" && !equalsnext && !ISNEXT (">")) ? OPER_GREATERTHAN :
 	return o;
 }
 // ============================================================================
+str ScriptReader::ParseFloat () {
+	MustNumber (true);
+	str floatstring = token;
+	// Go after the decimal point
+	if (PeekNext () == ".") {
+		Next (".");
+		MustNumber (false);
+		floatstring += ".";
+		floatstring += token;
+	}
+	return floatstring;
+}
+// ============================================================================
 // Parses a value in the expression and returns the data needed to push
 // it, contained in a data buffer. A value can be either a variable, a command,
 // a literal or an expression.
-DataBuffer* ScriptReader::ParseExprValue (int reqtype) {
+DataBuffer* ScriptReader::ParseExprValue (type_e reqtype) {
 	DataBuffer* b = new DataBuffer(16);
 	ScriptVar* g;
 	// Prefixing "!" means negation.
 	bool negate = (token == "!");
 	if (negate) // Jump past the "!"
 		Next ();
-	if (token == "(") {
+	// Handle strlen
+	if (token == "strlen") {
+		MustNext ("(");
+		MustNext ();
+		// By this token we should get a string constant.
+		constinfo_t* constant = FindConstant (token);
+		if (!constant || constant->type != TYPE_STRING)
+			ParserError ("strlen only works with const str");
+		if (reqtype != TYPE_INT)
+			ParserError ("strlen returns int but %s is expected\n", (char*)GetTypeName (reqtype));
+		b->Write<word> (DH_PUSHNUMBER);
+		b->Write<word> (constant->val.len ());
+		MustNext (")");
+	} else if (token == "(") {
 		// Expression
 		MustNext ();
 		DataBuffer* c = ParseExpression (reqtype);
 		b->Merge (c);
 		MustNext (")");
 		// Command
 		if (reqtype && comm->returnvalue != reqtype)
 			ParserError ("%s returns an incompatible data type", comm->name.chars());
 		b = ParseCommand (comm);
+	} else if (constinfo_t* constant = FindConstant (token)) {
+		// Type check
+		if (reqtype != constant->type)
+			ParserError ("constant `%s` is %s, expression requires %s\n",
+				(char*)constant->name, (char*)GetTypeName (constant->type),
+				(char*)GetTypeName (reqtype));
+		switch (constant->type) {
+		case TYPE_BOOL:
+		case TYPE_INT:
+			b->Write<word> (DH_PUSHNUMBER);
+			b->Write<word> (atoi (constant->val));
+			break;
+		case TYPE_FLOAT:
+			b->WriteFloat (constant->val);
+			break;
+		case TYPE_STRING:
+			b->WriteString (constant->val);
+			break;
+		case TYPE_VOID:
+		case TYPE_UNKNOWN:
+			break;
+		}
 	} else if ((g = FindGlobalVariable (token))) {
 		// Global variable
 		b->Write<word> (DH_PUSHGLOBALVAR);
 		b->Write<word> (g->index);
 	} else {
 		// If nothing else, check for literal
-		printf ("reqtype: %d\n", reqtype);
 		switch (reqtype) {
 		case TYPE_VOID:
+		case TYPE_UNKNOWN:
 			ParserError ("unknown identifier `%s` (expected keyword, function or variable)", token.chars());
 			break;
 		case TYPE_BOOL:
 		case TYPE_INT: {
 			MustNumber (true);
 		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.
 			MustString (true);
-			b->Write<word> (DH_PUSHSTRINGINDEX);
+			b->WriteString (token);
-			b->Write<word> (PushToStringTable (token.chars()));
 			break;
 		case TYPE_FLOAT: {
-			str floatstring;
+			str floatstring = ParseFloat ();
-			MustNumber (true);
-			floatstring += token;
-			// Go after the decimal point
-			if (PeekNext () == ".") {
-				MustNext (".");
-				MustNumber (false);
-				floatstring += ".";
-				floatstring += token;
-			}
-			// TODO: Casting float to word causes the decimal to be lost.
-			// Find a way to store the number without such loss.
-			float val = atof (floatstring);
-			b->Write<word> (DH_PUSHNUMBER);
-			b->Write<word> (static_cast<word> ((val > 0) ? val : -val));
-			if (val < 0)
-				b->Write<word> (DH_UNARYMINUS);
 			// TODO: Keep this check after decimal loss is fixed, but make
 			// it a real precision loss check. 55.5123 -> 55.512299, this
 			// should probably be warned of.
-			float check = static_cast<float> (static_cast<word> (val));
+			float check = static_cast<float> (static_cast<word> (atof (floatstring)));
-			if (val != check)
+			if (atof (floatstring) != check)
-				ParserWarning ("floating point number %f loses precision (-> %f)", val, check);
+				ParserWarning ("floating point number %f loses precision (-> %f)",
+					atof (floatstring), check);
+			b->WriteFloat (floatstring);
+			break;
 		}
 		}
 	}
 	// Negate it now if desired
 	bool global = !var->statename.len ();
 	// Get an operator
 	MustNext ();
 	int oper = ParseOperator ();
-	printf ("got operator %d\n", oper);
 	if (!IsAssignmentOperator (oper))
 		ParserError ("expected assignment operator");
 	if (g_CurMode == MODE_TOPLEVEL) // TODO: lift this restriction
 		ParserError ("can't alter variables at top level");
 		info->casenumbers[i] = -1;
 	}
 }
 DataBuffer* ScriptReader::ParseStatement (ObjWriter* w) {
+	if (FindConstant (token)) // There should not be constants here.
+		ParserError ("invalid use for constant\n");
 	// If it's a variable, expect assignment.
-	if (ScriptVar* var = FindGlobalVariable (token)) {
+	if (ScriptVar* var = FindGlobalVariable (token))
-		DataBuffer* b = ParseAssignment (var);
+		return ParseAssignment (var);
-		return b;
-	}
 	return NULL;
 }
 void ScriptReader::AddSwitchCase (ObjWriter* w, DataBuffer* b) {
 	// 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;
 }
+constinfo_t* FindConstant (str token) {
+	for (uint i = 0; i < g_ConstInfo.size(); i++)
+		if (g_ConstInfo[i].name == token)
+			return &g_ConstInfo[i];
+	return NULL;
+}

Mercurial > botc / file comparison

comparison: parser.cxx

parser.cxx