/// <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); } }