private void WriteVariable(Variable value, BinaryWriter writer)
{
writer.Write((int)value.Type);
switch (value.Type)
{
case VarType.String:
writer.Write(value.ToString());
break;
case VarType.Integer:
writer.Write(value.ToInteger());
break;
case VarType.Float:
writer.Write(value.ToFloat());
break;
case VarType.List:
writer.Write(value.ListCount);
foreach (var item in value.GetList())
{
WriteVariable(item, writer);
}
break;
default:
throw new Exception("Unable to write unknown variable type.");
}
}
private void EvalXor()
{
Variable var2 = VarStack.Pop();
Variable var1 = VarStack.Pop();
VarStack.Push(new Variable(var1.ToInteger() ^ var2.ToInteger()));
}
private void EvalCreateList()
{
// Create new array variable
bool result = EvalExpression();
Debug.Assert(result);
Variable size = VarStack.Pop();
VarStack.Push(Variable.CreateList(size.ToInteger()));
}
public int CompareTo(Variable value)
{
return(value.Type switch
{
VarType.String => CompareTo(value.ToString()),
VarType.Integer => CompareTo(value.ToInteger()),
VarType.Float => CompareTo(value.ToFloat()),
VarType.List => CompareTo((ListValue)value.Value),
_ => throw new InvalidOperationException(),
});
private void EvalListVariable()
{
Variable array = GetVariable(Reader.GetNextValue());
// Evaluate index
bool result = EvalExpression();
Debug.Assert(result);
Variable index = VarStack.Pop();
VarStack.Push(array.GetAt(index.ToInteger() - 1));
}
private void EvalNot()
{
Variable var = VarStack.Pop();
VarStack.Push(new Variable(~var.ToInteger()));
}
public override Variable Add(Variable value) => value.IsFloat() ? new Variable(Value + value.ToFloat()) : new Variable(Value + value.ToInteger());
public override Variable Add(Variable value) => (IsFloat() || value.IsFloat()) ? new Variable(ToFloat() + value.ToFloat()) : new Variable(ToInteger() + value.ToInteger());
public override Variable Modulus(Variable value) => (IsFloat() || value.IsFloat()) ? new Variable(ToFloat() % value.ToFloat()) : new Variable(ToInteger() % value.ToInteger());
public override Variable Multiply(Variable value) => (IsFloat() || value.IsFloat()) ? new Variable(ToFloat() * value.ToFloat()) : new Variable(ToInteger() * value.ToInteger());
public override Variable Subtract(Variable value) => (IsFloat() || value.IsFloat()) ? new Variable(ToFloat() - value.ToFloat()) : new Variable(ToInteger() - value.ToInteger());
public override bool IsEqual(Variable value) => (Value == value.ToInteger());
public override Variable Modulus(Variable value) => value.IsFloat() ? new Variable(Value % value.ToFloat()) : new Variable(Value % value.ToInteger());
public override Variable Multiply(Variable value) => value.IsFloat() ? new Variable(Value * value.ToFloat()) : new Variable(Value * value.ToInteger());
public override Variable Subtract(Variable value) => value.IsFloat() ? new Variable(Value - value.ToFloat()) : new Variable(Value - value.ToInteger());
/// <summary>
/// Parses a literal value where a full expression is not allowed, such
/// as in declarations within the header (before any functions). Logs
/// an error and returns false if a literal value was not found.
/// </summary>
/// <param name="variable">Returns the resulting variable if method returns true.</param>
/// <param name="allowLineBreak">If true, a new lines is allowed before literal.
/// Set to true when parsing array initialization within curly braces.</param>
internal bool ParseLiteral(out Variable variable, bool allowLineBreak = false)
{
variable = null;
bool negate = false;
Token token = allowLineBreak ? Lexer.GetNextSkipNewLines() : Lexer.GetNext();
if (token.Type == TokenType.LeftBracket)
{
// List size
if (!ParseLiteral(out variable))
{
return(false);
}
variable = Variable.CreateList(variable.ToInteger());
// Parse right bracket
token = Lexer.GetNext();
if (token.Type != TokenType.RightBracket)
{
Error(ErrorCode.ExpectedRightBracket, token);
NextLine();
return(false);
}
return(true);
}
if (token.Type == TokenType.LeftBrace)
{
// List initializers
List <Variable> list = new List <Variable>();
do
{
if (!ParseLiteral(out variable, true))
{
return(false);
}
list.Add(variable);
token = Lexer.GetNextSkipNewLines();
} while (token.Type == TokenType.Comma);
// Parse right brace
if (token.Type != TokenType.RightBrace)
{
Error(ErrorCode.ExpectedRightBrace, token);
NextLine();
return(false);
}
variable = new Variable(list);
return(true);
}
if (token.Type == TokenType.Minus || token.Type == TokenType.Plus)
{
negate = (token.Type == TokenType.Minus);
token = Lexer.GetNext();
}
if (token.IsLiteral)
{
variable = new Variable(token);
if (negate)
{
variable = variable.Negate();
}
return(true);
}
Error(ErrorCode.ExpectedLiteral, token);
return(false);
}
