botc: comparison src/Parser.cc

-:9174be9ac686
+:55c2bcd8ed5c
 			case tkFuncdef:
 				ParseFuncdef();
 				break;
+			case tkSemicolon:
+				break;
 			default:
 			{
 				// Check for labels
 				Lexer::Token next;
 				// If nothing else, parse it as a statement
 				mLexer->Skip (-1);
 				DataBuffer* b = ParseStatement();
 				if (b == false)
+				{
+					mLexer->GetNext();
 					Error ("unknown token `%1`", GetTokenString());
+				}
 				buffer()->MergeAndDestroy (b);
 				mLexer->MustGetNext (tkSemicolon);
+				break;
 			}
-			break;
 		}
 	}
 	// ===============================================================================
 	// Script file ended. Do some last checks and write the last things to main buffer
 //
 void BotscriptParser::ParseVar()
 {
 	Variable* var = new Variable;
 	var->origin = mLexer->DescribeCurrentPosition();
+	var->isarray = false;
 	const bool isconst = mLexer->GetNext (tkConst);
 	mLexer->MustGetAnyOf ({tkInt, tkStr, tkVoid});
 	EType vartype =	(TokenIs (tkInt)) ? EIntType :
 					(TokenIs (tkStr)) ? EStringType :
 					EBoolType;
 	mLexer->MustGetNext (tkSymbol);
 	String name = GetTokenString();
+	if (mLexer->GetNext (tkBracketStart))
+	{
+		mLexer->MustGetNext (tkBracketEnd);
+		var->isarray = true;
+		if (isconst)
+			Error ("arrays cannot be const");
+	}
 	for (Variable* var : SCOPE(0).globalVariables + SCOPE(0).localVariables)
 	{
 		if (var->name == name)
 			Error ("Variable $%1 is already declared on this scope; declared at %2",
 			var->value = expr.GetResult()->GetValue();
 		}
 		else
 		{
 			// TODO: might need a VM-wise oninit for this...
-			Error ("const variables must be constexpr for now");
+			Error ("const variables must be constexpr");
 		}
 	}
 	// Assign an index for the variable if it is not constexpr. Constexpr
 	// variables can simply be substituted out for their value when used
 			if (curarg < comm->minargs)
 				Error ("too few arguments passed to %1\n\tusage is: %2",
 					comm->name, comm->GetSignature());
 			break;
-			curarg++;
 		}
 		if (curarg >= comm->args.Size())
-			Error ("too many arguments passed to %1\n\tusage is: %2",
+			Error ("too many arguments (%3) passed to %1\n\tusage is: %2",
 				comm->name, comm->GetSignature());
 		r->MergeAndDestroy (ParseExpression (comm->args[curarg].type, true));
 		mLexer->MustGetNext (tkAny);
 	return (EAssignmentOperator) 0;
 }
 // ============================================================================
 //
+struct AssignmentDataHeaderInfo
+{
+	EAssignmentOperator	op;
+	EDataHeader			local;
+	EDataHeader			global;
+	EDataHeader			array;
+};
+const AssignmentDataHeaderInfo gAssignmentDataHeaders[] =
+{
+	{ EAssign,			dhAssignLocalVar,	dhAssignGlobalVar,		dhAssignGlobalArray },
+	{ EAssignAdd,		dhAddLocalVar,		dhAddGlobalVar,			dhAddGlobalArray },
+	{ EAssignSub,		dhSubtractLocalVar,	dhSubtractGlobalVar,	dhSubtractGlobalArray },
+	{ EAssignMul,		dhMultiplyLocalVar,	dhMultiplyGlobalVar,	dhMultiplyGlobalArray },
+	{ EAssignDiv,		dhDivideLocalVar,	dhDivideGlobalVar,		dhDivideGlobalArray },
+	{ EAssignMod,		dhModLocalVar,		dhModGlobalVar,			dhModGlobalArray },
+	{ EAssignIncrement,	dhIncreaseLocalVar,	dhIncreaseGlobalVar,	dhIncreaseGlobalArray },
+	{ EAssignDecrement,	dhDecreaseLocalVar,	dhDecreaseGlobalVar,	dhDecreaseGlobalArray },
+};
 EDataHeader BotscriptParser::GetAssigmentDataHeader (EAssignmentOperator op, Variable* var)
 {
-	if (var->IsGlobal())
+	for (const auto& a : gAssignmentDataHeaders)
 	{
-		switch (op)
+		if (a.op != op)
-		{
+			continue;
-			case EAssign:			return dhAssignGlobalVar;
-			case EAssignAdd:		return dhAddGlobalVar;
+		if (var->isarray)
-			case EAssignSub:		return dhSubtractGlobalVar;
+			return a.array;
-			case EAssignMul:		return dhMultiplyGlobalVar;
-			case EAssignDiv:		return dhDivideGlobalVar;
+		if (var->IsGlobal())
-			case EAssignMod:		return dhModGlobalVar;
+			return a.global;
-			case EAssignIncrement:	return dhIncreaseGlobalVar;
-			case EAssignDecrement:	return dhDecreaseGlobalVar;
+		return a.local;
-		}
+	}
-	}
+	Error ("WTF: couldn't find data header for operator #%1", op);
-	switch (op)
-	{
-		case EAssign:			return dhAssignLocalVar;
-		case EAssignAdd:		return dhAddLocalVar;
-		case EAssignSub:		return dhSubtractLocalVar;
-		case EAssignMul:		return dhMultiplyLocalVar;
-		case EAssignDiv:		return dhDivideLocalVar;
-		case EAssignMod:		return dhModLocalVar;
-		case EAssignIncrement:	return dhIncreaseLocalVar;
-		case EAssignDecrement:	return dhDecreaseLocalVar;
-	}
-	assert (false);
 	return (EDataHeader) 0;
 }
 // ============================================================================
 //
 // 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* BotscriptParser::ParseAssignment (Variable* var)
 {
+	DataBuffer* retbuf = new DataBuffer;
+	DataBuffer* arrayindex = null;
 	if (var->writelevel != Variable::WRITE_Mutable)
-	{
 		Error ("cannot alter read-only variable $%1", var->name);
+	if (var->isarray)
+	{
+		mLexer->MustGetNext (tkBracketStart);
+		Expression expr (this, mLexer, EIntType);
+		expr.GetResult()->ConvertToBuffer();
+		arrayindex = expr.GetResult()->GetBuffer()->Clone();
+		mLexer->MustGetNext (tkBracketEnd);
 	}
 	// Get an operator
 	EAssignmentOperator oper = ParseAssignmentOperator();
-	DataBuffer* retbuf = new DataBuffer;
 	if (mCurrentMode == ETopLevelMode)
 		Error ("can't alter variables at top level");
 	// Parse the right operand
 	if (oper != EAssignIncrement && oper != EAssignDecrement)
 	{
 		DataBuffer* expr = ParseExpression (var->type);
 		retbuf->MergeAndDestroy (expr);
 	}
+	if (var->isarray)
+		retbuf->MergeAndDestroy (arrayindex);
 #if 0
 	// <<= and >>= do not have data headers. Solution: expand them.
 	// a <<= b -> a = a << b
 	// a >>= b -> a = a >> b

Mercurial > botc / file comparison

comparison: src/Parser.cc

src/Parser.cc