/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken nameValueToGet;
if (interpreterEnvironment.NameStack.Count > 0)
{
nameValueToGet = interpreterEnvironment.NameStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
if (interpreterEnvironment.DefinedValues.ContainsKey(nameValueToGet.Data[0]))
{
interpreterEnvironment.ValueStack.Push(interpreterEnvironment.DefinedValues[nameValueToGet.Data[0]]);
return(true);
}
else
{
Errors.UndefinedName.Report(
nameValueToGet.Position.File,
nameValueToGet.Position.Line,
nameValueToGet.Position.Column,
nameValueToGet.Data[0]
);
return(false);
}
}
public override IExpression Call(InterpreterEnvironment env, IEnumerable <IExpression> args)
{
// Unexpected number of arguments
if (args.Count() != Arguments.Count())
{
throw new UnexpectedNumberOfArgumentsException(Name, Arguments.Count(), args.Count());
}
// The body expression is a function call expression
if (Body is CallExpression)
{
InterpreterEnvironment innerEnv = new InterpreterEnvironment(env);
int argCount = args.Count();
for (int i = 0; i < argCount; i++)
{
innerEnv.Symbols[Arguments.ElementAt(i)] = args.ElementAt(i);
}
return(Body.Evaluate(innerEnv));
}
// The body expression is anything else than a function call expression
else
{
return(Body.Evaluate(env));
}
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
return(new InterpreterResult()
{
Value = Value, Type = InterpreterVariableType.String
});
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
return(new InterpreterResult()
{
Type = InterpreterVariableType.Boolean, Value = Value
});
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterVariable variable = null;
if (Variable.IsLast)
{
if (Env.CurrentContext.LastVariable == null)
{
throw new InterpreterException("Invalid use of " + Variable.T.Value, Variable.T);
}
variable = Env.CurrentContext.LastVariable;
}
else if (Env.CurrentContext.VariableExists(Variable.Name))
{
variable = Env.CurrentContext.GetVariable(Variable.Name);
}
else
{
variable = new InterpreterVariable(Variable.Name, InterpreterVariableType.Undefined);
Env.CurrentContext.AddVariable(variable);
}
InterpreterResult result = Value.Interpret(Env);
variable.Type = result.Type;
variable.Value = result.Value;
return(new InterpreterResult()
{
Value = variable.Value, Type = result.Type
});
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
return(new InterpreterResult()
{
Type = InterpreterVariableType.Null, Value = null
});
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterResult lhsResult = LHS.Interpret(Env);
InterpreterResult rhsResult = RHS.Interpret(Env);
if (lhsResult.Type == InterpreterVariableType.Undefined || rhsResult.Type == InterpreterVariableType.Undefined ||
lhsResult.Value == null || rhsResult.Value == null)
{
throw new InterpreterException("Unable to divide mysterious", T);
}
decimal?lhs = InterpreterVariable.GetNumericValueFor(lhsResult.Value);
decimal?rhs = InterpreterVariable.GetNumericValueFor(rhsResult.Value);
if (!lhs.HasValue || !rhs.HasValue)
{
throw new InterpreterException("Unable to divide mysterious", T);
}
if (rhs.Value == 0)
{
throw new InterpreterException("Divide by zero error", T);
}
return(new InterpreterResult()
{
Type = InterpreterVariableType.Numeric, Value = lhs.Value / rhs.Value
});
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
if (IsLast)
{
if (Env.CurrentContext.LastVariable != null)
{
InterpreterVariable v = Env.CurrentContext.LastVariable;
return(new InterpreterResult()
{
Type = v.Type, Value = v.Value
});
}
throw new InterpreterException("Invalid use of " + T.Value, T);
}
if (Env.CurrentContext.VariableExists(Name))
{
InterpreterVariable v = Env.CurrentContext.GetVariable(Name);
return(new InterpreterResult()
{
Value = v.Value, Type = v.Type
});
}
return(new InterpreterResult()
{
Type = InterpreterVariableType.Undefined
});
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterVariable variable = null;
if (Variable.IsLast)
{
if (Env.CurrentContext.LastVariable != null)
{
variable = Env.CurrentContext.LastVariable;
}
else
{
throw new InterpreterException("Invalid use of " + Variable.T.Value, Variable.T);
}
}
else if (Env.CurrentContext.VariableExists(Variable.Name))
{
variable = Env.CurrentContext.GetVariable(Variable.Name);
}
else
{
variable = new InterpreterVariable(Variable.Name, InterpreterVariableType.String);
Env.CurrentContext.AddVariable(variable);
}
if (variable.Type != InterpreterVariableType.String)
{
variable.Type = InterpreterVariableType.String;
}
variable.Value = Console.ReadLine();
return(new InterpreterResult()
{
Type = InterpreterVariableType.Null
});
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken b;
TransformedToken a;
if (interpreterEnvironment.ValueStack.Count >= 2)
{
b = interpreterEnvironment.ValueStack.Pop();
a = interpreterEnvironment.ValueStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
interpreterEnvironment.ValueStack.Push(
new TransformedToken(
a.Position,
TransformedTokenType.Bool,
a.Data != b.Data
)
);
return(true);
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
object value = null;
if (ToSay is VariableParseNode)
{
VariableParseNode variableNode = ToSay as VariableParseNode;
InterpreterVariable variable = null;
if (variableNode.IsLast)
{
if (Env.CurrentContext.LastVariable != null)
{
variable = Env.CurrentContext.LastVariable;
}
else
{
throw new InterpreterException("Invalid use of " + variableNode.T.Value, variableNode.T);
}
}
else if (Env.CurrentContext.VariableExists(variableNode.Name))
{
variable = Env.CurrentContext.GetVariable(variableNode.Name);
}
else
{
Console.WriteLine("mysterious");
return(new InterpreterResult());
}
if (variable.Type == InterpreterVariableType.Null)
{
Console.WriteLine("null");
return(new InterpreterResult());
}
if (variable.Type == InterpreterVariableType.Undefined)
{
Console.WriteLine("mysterious");
return(new InterpreterResult());
}
value = variable.Value;
}
else
{
InterpreterResult result = ToSay.Interpret(Env);
if (result.Type == InterpreterVariableType.Null)
{
Console.WriteLine("null");
}
else if (result.Type == InterpreterVariableType.Undefined)
{
Console.WriteLine("mysterious");
}
else
{
value = result.Value;
}
}
Console.WriteLine(value);
return(new InterpreterResult());
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
foreach (ParseNode node in Nodes)
{
node.Interpret(Env);
}
return(new InterpreterResult());
}
public override IExpression Evaluate(InterpreterEnvironment env)
{
// Register the function as a symbol in the currect environment
env.Symbols[Name] = this;
// Perform the default behavior
return(base.Evaluate(env));
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken b;
TransformedToken a;
if (interpreterEnvironment.ValueStack.Count >= 2)
{
b = interpreterEnvironment.ValueStack.Pop();
a = interpreterEnvironment.ValueStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
if (a.Type == TransformedTokenType.Number && b.Type == TransformedTokenType.Number)
{
interpreterEnvironment.ValueStack.Push(
new TransformedToken(
a.Position,
TransformedTokenType.Number,
a.Data[0] * b.Data[0]
)
);
return(true);
}
else if (a.Type == TransformedTokenType.String && b.Type == TransformedTokenType.Number)
{
interpreterEnvironment.ValueStack.Push(
new TransformedToken(
a.Position,
TransformedTokenType.String,
string.Concat(Enumerable.Repeat(a.Data[0], (int)b.Data[0]))
)
);
return(true);
}
else
{
Errors.IncompatibleOperatorTypes.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
a.Type,
b.Type,
this.Name
);
return(false);
}
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterResult result = null;
while ((result = Condition.Interpret(Env)).Type == InterpreterVariableType.Boolean && !(result.Value as bool?).Value)
{
Block.Interpret(Env);
}
return(new InterpreterResult());
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken shouldDuplicate;
TransformedToken nameToDuplicate;
if (interpreterEnvironment.ValueStack.Count > 0)
{
shouldDuplicate = interpreterEnvironment.ValueStack.Pop();
if (shouldDuplicate.Type != TransformedTokenType.Bool)
{
Errors.InvalidValue.Report(
shouldDuplicate.Position.File,
shouldDuplicate.Position.Line,
shouldDuplicate.Position.Column,
shouldDuplicate.Data[0]
);
return(false);
}
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
if (interpreterEnvironment.NameStack.Count > 0)
{
if (shouldDuplicate.Data[0])
{
nameToDuplicate = interpreterEnvironment.NameStack.Peek();
interpreterEnvironment.NameStack.Push(nameToDuplicate);
}
return(true);
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken nameValue;
TransformedToken name;
if (interpreterEnvironment.ValueStack.Count > 0 && interpreterEnvironment.NameStack.Count > 0)
{
nameValue = interpreterEnvironment.ValueStack.Pop();
name = interpreterEnvironment.NameStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
if (
nameValue.Type == TransformedTokenType.Bool ||
nameValue.Type == TransformedTokenType.String ||
nameValue.Type == TransformedTokenType.Number
)
{
if (!interpreterEnvironment.DefinedValues.ContainsKey(name.Data[0]))
{
interpreterEnvironment.DefinedValues.Add(name.Data[0], nameValue);
}
else
{
interpreterEnvironment.DefinedValues[name.Data[0]] = nameValue;
}
return(true);
}
else
{
Errors.InvalidValue.Report(
name.Position.File,
name.Position.Line,
name.Position.Column,
name.Data[0]
);
return(false);
}
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterResult comparisonResult = Comparison.Interpret(Env);
if ((comparisonResult.Value as bool?).Value)
{
return(new InterpreterResult()
{
Value = false, Type = InterpreterVariableType.Boolean
});
}
return(new InterpreterResult()
{
Value = true, Type = InterpreterVariableType.Boolean
});
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
if (interpreterEnvironment.LabelStack.Count > 0)
{
interpreterEnvironment.LabelStack.Pop();
return(true);
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken labelToDuplicate;
if (interpreterEnvironment.LabelStack.Count > 0)
{
labelToDuplicate = interpreterEnvironment.LabelStack.Peek();
interpreterEnvironment.LabelStack.Push(labelToDuplicate);
return(true);
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken tokenToWrite;
if (interpreterEnvironment.ValueStack.Count > 0)
{
tokenToWrite = interpreterEnvironment.ValueStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
Console.WriteLine(string.Join("", tokenToWrite.Data));
return(true);
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterVariable variable = null;
if (Variable.IsLast)
{
if (Env.CurrentContext.LastVariable == null)
{
throw new InterpreterException("Invalid use of " + Variable.T.Value, Variable.T);
}
variable = Env.CurrentContext.LastVariable;
}
else if (Env.CurrentContext.VariableExists(Variable.Name))
{
variable = Env.CurrentContext.GetVariable(Variable.Name);
}
else
{
variable = new InterpreterVariable(Variable.Name, InterpreterVariableType.Undefined);
Env.CurrentContext.AddVariable(variable);
}
variable.Type = InterpreterVariableType.String;
string value = "";
List <ParseNode> words = Words.GetNodes();
foreach (ParseNode node in words)
{
WordParseNode word = node as WordParseNode;
value += word.Text + " ";
}
if (value.Length > 0)
{
value = value.Substring(0, value.Length - 1);
}
variable.Value = value;
return(new InterpreterResult());
}
public IExpression Evaluate(InterpreterEnvironment env)
{
// Evaluate the function expression
Function evaluatedFunc = Function.Evaluate(env) as Function;
if (evaluatedFunc == null)
{
throw new FatalException($"Unexpected function call syntax (\"{Function}\" does not evaluate to a function)");
}
if (evaluatedFunc is BuiltInFunction)
{
// Call the evaluated function with the unevaluated arguments
return(evaluatedFunc.Call(env, Arguments));
}
else
{
// Evaluate the function arguments
IEnumerable <IExpression> evalArgs = Arguments.Select(x => x.Evaluate(env));
// Call the evaluated function with the evaluated arguments
return(evaluatedFunc.Call(env, evalArgs));
}
}
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
throw new NotImplementedException();
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken label;
if (interpreterEnvironment.LabelStack.Count > 0)
{
label = interpreterEnvironment.LabelStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
if (label.Type == TransformedTokenType.LabelUsage)
{
if (interpreterEnvironment.DefinedLabels.ContainsKey(label.Data[0]))
{
if (interpreter.InputTokens[interpreterEnvironment.DefinedLabels[label.Data[0]]].Type == TransformedTokenType.LabelDefinition)
{
interpreterEnvironment.CallStack.Push(interpreterEnvironment.CurrentTokenIndex);
interpreterEnvironment.CurrentTokenIndex = interpreterEnvironment.DefinedLabels[label.Data[0]];
return(true);
}
else
{
Errors.InvalidLabelType.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column
);
return(false);
}
}
else
{
Errors.UnknownLabel.Report(
label.Data[0],
label.Position.Line,
label.Position.Column
);
return(false);
}
}
else if (label.Type == TransformedTokenType.StacklessLabelUsage)
{
if (interpreterEnvironment.DefinedLabels.ContainsKey(label.Data[0]))
{
if (interpreter.InputTokens[interpreterEnvironment.DefinedLabels[label.Data[0]]].Type == TransformedTokenType.StacklessLabelDefinition)
{
interpreterEnvironment.CurrentTokenIndex = interpreterEnvironment.DefinedLabels[label.Data[0]];
return(true);
}
else
{
Errors.InvalidLabelType.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column
);
return(false);
}
}
else
{
Errors.UnknownLabel.Report(
label.Position.File,
label.Position.Line,
label.Position.Column,
label.Data[0]
);
return(false);
}
}
else
{
Errors.InvalidToken.Report(
label.Position.File,
label.Position.Line,
label.Position.Column,
label.Data[0]
);
return(false);
}
}
public IExpression Evaluate(InterpreterEnvironment env) => env.FindSymbol(Symbol);
public virtual IExpression Evaluate(InterpreterEnvironment env) => this;
public abstract IExpression Call(InterpreterEnvironment env, IEnumerable <IExpression> args);
public override InterpreterResult Interpret(InterpreterEnvironment Env)
{
InterpreterResult lhsResult = LHS.Interpret(Env);
InterpreterResult rhsResult = RHS.Interpret(Env);
InterpreterResult trueResult = new InterpreterResult()
{
Value = true, Type = InterpreterVariableType.Boolean
};
InterpreterResult falseResult = new InterpreterResult()
{
Value = false, Type = InterpreterVariableType.Boolean
};
if (lhsResult.Value == null && rhsResult.Value == null)
{
return(trueResult);
}
if (lhsResult.Type == InterpreterVariableType.NaN && rhsResult.Type == InterpreterVariableType.NaN)
{
return(trueResult);
}
if (lhsResult.Type == InterpreterVariableType.Null && rhsResult.Type == InterpreterVariableType.Null)
{
return(trueResult);
}
if (lhsResult.Type == InterpreterVariableType.Undefined && rhsResult.Type == InterpreterVariableType.Undefined)
{
return(trueResult);
}
if (lhsResult.Type == InterpreterVariableType.Numeric && rhsResult.Type == InterpreterVariableType.Numeric)
{
if ((lhsResult.Value as decimal?).Value == (rhsResult.Value as decimal?).Value)
{
return(trueResult);
}
return(falseResult);
}
if (lhsResult.Type == InterpreterVariableType.String && lhsResult.Type == InterpreterVariableType.String)
{
if (lhsResult.Value as string == rhsResult.Value as string)
{
return(trueResult);
}
return(falseResult);
}
decimal?lhsNumVal = InterpreterVariable.GetNumericValueFor(lhsResult.Value);
decimal?rhsNumVal = InterpreterVariable.GetNumericValueFor(rhsResult.Value);
if (lhsNumVal.HasValue && rhsNumVal.HasValue && lhsNumVal.Value == rhsNumVal.Value)
{
return(trueResult);
}
return(falseResult);
}
/// <summary>
/// Execute the function.
/// </summary>
/// <param name="interpreter">A reference to the current interpreter.</param>
/// <param name="interpreterEnvironment">A reference to the current interpreter environment.</param>
public override bool Execute(Interpreter interpreter, InterpreterEnvironment interpreterEnvironment)
{
TransformedToken callIf;
TransformedToken label;
if (interpreterEnvironment.ValueStack.Count > 0 && interpreterEnvironment.LabelStack.Count > 0)
{
callIf = interpreterEnvironment.ValueStack.Pop();
label = interpreterEnvironment.LabelStack.Pop();
}
else
{
Errors.EmptyStack.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Data[0]
);
return(false);
}
if (label.Type == TransformedTokenType.LabelUsage)
{
if (callIf.Type == TransformedTokenType.Bool)
{
if (interpreterEnvironment.DefinedLabels.ContainsKey(label.Data[0]))
{
if (interpreter.InputTokens[interpreterEnvironment.DefinedLabels[label.Data[0]]].Type == TransformedTokenType.LabelDefinition)
{
if (callIf.Data[0])
{
interpreterEnvironment.CallStack.Push(interpreterEnvironment.CurrentTokenIndex);
interpreterEnvironment.CurrentTokenIndex = interpreterEnvironment.DefinedLabels[label.Data[0]];
}
return(true);
}
else
{
Errors.InvalidLabelType.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column
);
return(false);
}
}
else
{
Errors.UnknownLabel.Report(
label.Data[0],
label.Position.Line,
label.Position.Column
);
return(false);
}
}
else
{
Errors.InvalidValue.Report(
callIf.Data[0],
callIf.Position.Line,
callIf.Position.Column
);
return(false);
}
}
else if (label.Type == TransformedTokenType.StacklessLabelUsage)
{
if (callIf.Type == TransformedTokenType.Bool)
{
if (interpreterEnvironment.DefinedLabels.ContainsKey(label.Data[0]))
{
if (interpreter.InputTokens[interpreterEnvironment.DefinedLabels[label.Data[0]]].Type == TransformedTokenType.StacklessLabelDefinition)
{
if (callIf.Data[0])
{
interpreterEnvironment.CurrentTokenIndex = interpreterEnvironment.DefinedLabels[label.Data[0]];
}
return(true);
}
else
{
foreach (System.Collections.Generic.KeyValuePair <string, int> lbl in interpreterEnvironment.DefinedLabels)
{
Console.WriteLine(lbl.Key);
}
Errors.InvalidLabelType.Report(
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.File,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Line,
interpreter.InputTokens[interpreterEnvironment.CurrentTokenIndex].Position.Column
);
return(false);
}
}
else
{
Errors.UnknownLabel.Report(
label.Position.File,
label.Position.Line,
label.Position.Column,
label.Data[0]
);
return(false);
}
}
else
{
Errors.InvalidValue.Report(
callIf.Position.File,
callIf.Position.Line,
callIf.Position.Column,
callIf.Data[0]
);
return(false);
}
}
else
{
Errors.InvalidToken.Report(
label.Position.File,
label.Position.Line,
label.Position.Column,
label.Data[0]
);
return(false);
}
}
