public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (!(tokenMarker.Token is StringValueToken stringValueToken)) { throw new Exceptions.SyntaxErrorException(); } }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { var variableNameToken = tokenMarker.Token as VariableNameToken; ValueTokenArray indicies = null; if (variableNameToken == null) { throw new Exceptions.SyntaxErrorException(); } if (tokenMarker.PeekNext() is OpenParenToken) { indicies = interpreter.ExpressionEvaluator.EvaluateVariableArrayAssignment(tokenMarker); } else { tokenMarker.MoveNext(); } var equalsToken = tokenMarker.Token; if (!(equalsToken is Operators.EqualToken)) { throw new Exceptions.SyntaxErrorException(); } if (tokenMarker.GetNextToken() == null) { throw new Exceptions.SyntaxErrorException(); } var result = interpreter.ExpressionEvaluator.Evaluate(tokenMarker); interpreter.VariablesEnvironment.SetVariableValue(variableNameToken, indicies, result); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { // For an empty PRINT command, just output a writeline and return. if (tokenMarker.Token == null) { interpreter.Console.OutputTextWriter.WriteLine(); return; } Token lastToken = null; while (tokenMarker.Token != null) { lastToken = tokenMarker.Token; switch (tokenMarker.Token) { case StringValueToken stringValueToken: case RealValueToken realValueToken: case IntegerValueToken integerValueToken: case UnaryMinusToken unaryMinusToken: case MinusToken minusToken: case PlusToken plusToken: case VariableNameToken variableToken: case FunctionToken functionToken: case FnToken userDefinedFunctionToken: case OpenParenToken openParenToken: var result = interpreter.ExpressionEvaluator.Evaluate(tokenMarker); WriteValue(interpreter, result); break; case SemicolonToken semiColonToken: tokenMarker.MoveNext(); break; case CommaToken commaToken: MoveToNextTabMargin(interpreter); tokenMarker.MoveNext(); break; case TabToken tabToken: tokenMarker.MoveNext(); tabToken.Execute(interpreter, tokenMarker); break; case SpcToken spcToken: tokenMarker.MoveNext(); spcToken.Execute(interpreter, tokenMarker); break; default: throw new Exceptions.SyntaxErrorException(); } // lastToken = tokenMarker.Token; // tokenMarker.MoveNext(); } if (!((lastToken is SemicolonToken) || (lastToken is CommaToken))) { interpreter.Console.OutputTextWriter.WriteLine(); } }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { while (tokenMarker.Token != null) { if (!(tokenMarker.Token is VariableNameToken variableNameToken)) { throw new Exceptions.SyntaxErrorException(); } if (!(tokenMarker.PeekNext() is OpenParenToken)) { throw new Exceptions.SyntaxErrorException(); } var indicies = interpreter.ExpressionEvaluator.EvaluateVariableArrayAssignment(tokenMarker); interpreter.VariablesEnvironment.DimensionArrayVariable(variableNameToken, indicies); if (!(tokenMarker.Token is CommaToken)) { break; } tokenMarker.MoveNext(); } }
public static TokenMarker[] MeanSquareOrthogonalReferenceSystemOptimized(TokenMarker originalOrigin, TokenMarker originalXAxis, TokenMarker originalYAxis, TokenMarker originalData, float originToAxisDistance, int[] dataCoordinates) { TokenMarker[] result = new TokenMarker[3]; float[] meanSquareSolution = new float[4]; float ox = originalOrigin.Position.x, oy = originalOrigin.Position.y, xx = originalXAxis.Position.x, xy = originalXAxis.Position.y, yx = originalYAxis.Position.x, yy = originalYAxis.Position.y; meanSquareSolution[0] = (-ox - oy + (2 * xx) - xy - yx + (2 * yy)) / (originToAxisDistance * 4); meanSquareSolution[1] = -((-ox + oy - xx - (2 * xy) + (2 * yx) + yy) / (originToAxisDistance * 4)); meanSquareSolution[2] = -((-(2 * ox) - xx - xy - yx + yy) / 4f); meanSquareSolution[3] = ((2 * oy) - xx + xy + yx + yy) / 4f; Vector2 newOrigin = new Vector2(meanSquareSolution[2], meanSquareSolution[3]); Vector2 newXAxis = new Vector2(originToAxisDistance * meanSquareSolution[0] + meanSquareSolution[2], originToAxisDistance * meanSquareSolution[1] + meanSquareSolution[3]); Vector2 newYAxis = new Vector2(-originToAxisDistance * meanSquareSolution[1] + meanSquareSolution[2], originToAxisDistance * meanSquareSolution[0] + meanSquareSolution[3]); result[0] = new TokenMarker(originalOrigin.Id, newOrigin, originalOrigin.State, MarkerType.Origin); result[1] = new TokenMarker(originalXAxis.Id, newXAxis, originalXAxis.State, MarkerType.XAxis); result[2] = new TokenMarker(originalYAxis.Id, newYAxis, originalYAxis.State, MarkerType.YAxis); return(result); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { string fileName; switch (tokenMarker.Token) { case StringValueToken stringValueToken: fileName = stringValueToken.Value; break; case VariableNameToken variableNameToken: var evalToken = interpreter.ExpressionEvaluator.Evaluate(tokenMarker); if (evalToken is StringValueToken evalStringToken) { fileName = evalStringToken.Value; break; } throw new Exceptions.SyntaxErrorException(); default: throw new Exceptions.SyntaxErrorException(); } interpreter.LoadFromFile(fileName); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (tokenMarker.Token != null) { throw new Exceptions.SyntaxErrorException(); } interpreter.ClearAll(); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { var variableNameTokens = new List <VariableNameToken>(); while (tokenMarker.Token != null) { if (!(tokenMarker.Token is VariableNameToken variableNameToken)) { throw new Exceptions.SyntaxErrorException(); } if (!((variableNameToken.VariableType == VariableValueType.IntegerNumber) || (variableNameToken.VariableType == VariableValueType.RealNumber))) { throw new Exceptions.TypeMismatchException(); } variableNameTokens.Add(variableNameToken); // Maybe add more variable names to the list if (tokenMarker.GetNextToken() is CommaToken) { tokenMarker.MoveNext(); continue; } } if (interpreter.ForNextLoops.Count == 0) { throw new Exceptions.NextWithoutForException(); } if (variableNameTokens.Count == 0) { ProcessForNextState(interpreter, interpreter.ForNextLoops.Peek()); return; } int variableNameIndex = 0; while (variableNameIndex < variableNameTokens.Count) { if (interpreter.ForNextLoops.TryPeek(out ForNextLoopState forNextState) == false) { throw new Exceptions.NextWithoutForException(); } bool forNextLoopDone = ProcessForNextState(interpreter, forNextState, variableNameTokens[variableNameIndex]); if (!forNextLoopDone) { return; } variableNameIndex += 1; } }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { try { var returnMarker = interpreter.GosubMarkers.Pop(); // returnMarker.MoveToNextStatement(); interpreter.NextStatementMarker = returnMarker; } catch (InvalidOperationException) { throw new Exceptions.ReturnWithoutGosubException(); } }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (tokenMarker.Token != null) { throw new Exceptions.SyntaxErrorException(); } if (interpreter.CurrentStatementMarker != null && interpreter.CurrentStatementMarker.Valid == false) { throw new Exceptions.CantContinueException(); } interpreter.ContinueRun(); }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken[] valueTokens) { // A separate expression evaluator is needed since the one created by the interpreter // has state unrelated to this statement's state. if (expressionEvaluator == null) { expressionEvaluator = new ExpressionEvaluator(interpreter); } interpreter.VariablesEnvironment.SetVariableValue(variableNameToken, valueTokens[0]); var marker = new TokenMarker(statement.Tokens); return(expressionEvaluator.Evaluate(marker)); }
/// <summary> /// Converts a series of TouchInputs present in a cluster to TokenMarkers with specific <see cref="MarkerType"/> /// </summary> /// <param name="orderedIndexes">Array of indexes ordered according to <see cref="MarkerType"/> </param> /// <param name="clusterPoints">Dictionary of TouchInputs present in a cluster</param> /// <returns>A dictionary of TokenMarkers with their ID as key</returns> public static Dictionary <int, TokenMarker> ConvertTouchInputToMarkers(int[] orderedIndexes, Dictionary <int, TouchInput> clusterPoints) { Dictionary <int, TokenMarker> result = new Dictionary <int, TokenMarker>(); for (int i = 0; i < orderedIndexes.Length; i++) { TouchInput ti = clusterPoints[orderedIndexes[i]]; // ordered index is organized: // [0] => Origin // [1] => XAxis // [2] => YAxis // [3] => Data switch (i) { case 0: { TokenMarker tm = new TokenMarker(ti.Id, ti.Position, ti.State, MarkerType.Origin); result.Add(tm.Id, tm); break; } case 1: { TokenMarker tm = new TokenMarker(ti.Id, ti.Position, ti.State, MarkerType.XAxis); result.Add(tm.Id, tm); break; } case 2: { TokenMarker tm = new TokenMarker(ti.Id, ti.Position, ti.State, MarkerType.YAxis); result.Add(tm.Id, tm); break; } case 3: { TokenMarker tm = new TokenMarker(ti.Id, ti.Position, ti.State, MarkerType.Data); result.Add(tm.Id, tm); break; } } } return(result); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { // TAB is only valid inside a PRINT command. if (!(interpreter.CurrentCommandToken is PrintToken)) { throw new Exceptions.SyntaxErrorException(); } // Make sure next token is a '('. if (tokenMarker.Token == null || !(tokenMarker.Token is OpenParenToken)) { throw new Exceptions.SyntaxErrorException(); } var valueToken = interpreter.ExpressionEvaluator.Evaluate(tokenMarker); if (!(valueToken is NumericValueToken numericValueToken)) { throw new Exceptions.TypeMismatchException(); } // Make sure last token in expression ended in a ')'. if (!(tokenMarker.PeekPrev() is CloseParenToken)) { throw new Exceptions.SyntaxErrorException(); } var newColumn = numericValueToken.IntValue; if (newColumn < 0 || newColumn > 255) { throw new Exceptions.IllegalQuantityException(); } // If the current cursor column is already beyond the new column, don't move the cursor if (interpreter.Console.CursorColumn > newColumn) { return; } interpreter.Console.Tab(newColumn); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (tokenMarker.Token == null) { interpreter.Run(); return; } if (!(tokenMarker.Token is NumericValueToken numericValueToken)) { throw new Exceptions.SyntaxErrorException(); } if (tokenMarker.PeekNext() != null) { throw new Exceptions.SyntaxErrorException(); } interpreter.Run(numericValueToken.IntValue); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (!(tokenMarker.Token is ToToken)) { throw new Exceptions.SyntaxErrorException(); } if (!(tokenMarker.GetNextToken() is NumericValueToken numberToken)) { throw new Exceptions.SyntaxErrorException(); } var gotoMarker = interpreter.CreateStatementMarker(); if (gotoMarker.MoveToLine(numberToken.IntValue) == false) { throw new Exceptions.UndefinedStatementException(); } interpreter.NextStatementMarker = gotoMarker; }
/// <summary> /// Computes the closest orthogonal reference system to the one originally detected with a mean square solution /// </summary> /// <param name="originalOrigin">Originally detected Origin marker</param> /// <param name="originalXAxis">Originally detected X Axis marker</param> /// <param name="originalYAxis">Originally detected Y Axis marker</param> /// <param name="originToAxisDistance"> Distance between Origin marker and Axis markers</param> /// <returns>Array of TokenMarkers reppresdenting the closest orthgoanl reference system with respect to the specified one</returns> public static TokenMarker[] MeanSquareOrthogonalReferenceSystem(TokenMarker originalOrigin, TokenMarker originalXAxis, TokenMarker originalYAxis, float originToAxisDistance) { TokenMarker[] result = new TokenMarker[3]; var M = Matrix <float> .Build; float[,] arrayA = { { 0.0f, 0.0f, 1.0f, 0.0f }, { 0.0f, 0.0f, 0.0f, 1.0f }, { originToAxisDistance, 0.0f, 1.0f, 0.0f }, { 0.0f, originToAxisDistance, 0.0f, 1.0f }, { 0.0f, -originToAxisDistance, 1.0f, 0.0f }, { originToAxisDistance, 0.0f, 0.0f, 1.0f } }; float[,] arrayB = { { originalOrigin.Position.x }, { originalOrigin.Position.y }, { originalXAxis.Position.x }, { originalXAxis.Position.y }, { originalYAxis.Position.x }, { originalYAxis.Position.y } }; var A = M.DenseOfArray(arrayA); var b = M.DenseOfArray(arrayB); var x = A.TransposeThisAndMultiply(A).Inverse() * A.TransposeThisAndMultiply(b); float[,] transformationMatrix = x.ToArray(); Vector2 newOrigin = new Vector2(transformationMatrix[2, 0], transformationMatrix[3, 0]); Vector2 newXAxis = new Vector2(originToAxisDistance * transformationMatrix[0, 0] + transformationMatrix[2, 0], originToAxisDistance * transformationMatrix[1, 0] + transformationMatrix[3, 0]); Vector2 newYAxis = new Vector2(-originToAxisDistance * transformationMatrix[1, 0] + transformationMatrix[2, 0], originToAxisDistance * transformationMatrix[0, 0] + transformationMatrix[3, 0]); result[0] = new TokenMarker(originalOrigin.Id, newOrigin, originalOrigin.State, MarkerType.Origin); result[1] = new TokenMarker(originalXAxis.Id, newXAxis, originalXAxis.State, MarkerType.XAxis); result[2] = new TokenMarker(originalYAxis.Id, newYAxis, originalYAxis.State, MarkerType.YAxis); return(result); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (!(tokenMarker.Token is NumericValueToken lineNumberToken)) { throw new Exceptions.UndefinedStatementException(); } var currentMarker = interpreter.CopyCurrentStatementMarker(); currentMarker.MoveToNextStatement(); interpreter.GosubMarkers.Push(currentMarker); var gotoMarker = interpreter.CreateStatementMarker(); if (gotoMarker.MoveToLine(lineNumberToken.IntValue) == false) { throw new Exceptions.UndefinedStatementException(); } interpreter.NextStatementMarker = gotoMarker; }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (tokenMarker.Token == null || !(tokenMarker.Token is NumericValueToken numberToken)) { throw new Exceptions.UndefinedStatementException(); } if (interpreter.InterpreterMode == InterpreterMode.Immmediate) { interpreter.WarmRun(numberToken.IntValue); return; } var gotoMarker = interpreter.CreateStatementMarker(); if (gotoMarker.MoveToLine(numberToken.IntValue) == false) { throw new Exceptions.UndefinedStatementException(); } interpreter.NextStatementMarker = gotoMarker; }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { // SPC is only valid inside a PRINT command if (!(interpreter.CurrentCommandToken is PrintToken)) { throw new Exceptions.SyntaxErrorException(); } // Make sure next token is a '('. if (tokenMarker.Token == null || !(tokenMarker.Token is OpenParenToken)) { throw new Exceptions.SyntaxErrorException(); } var valueToken = interpreter.ExpressionEvaluator.Evaluate(tokenMarker); if (!(valueToken is NumericValueToken numericValueToken)) { throw new Exceptions.TypeMismatchException(); } // Make sure last token in expression ended in a ')'. if (!(tokenMarker.PeekPrev() is CloseParenToken)) { throw new Exceptions.SyntaxErrorException(); } var value = numericValueToken.IntValue; if (value < 0 || value > 255) { throw new Exceptions.IllegalQuantityException(); } interpreter.Console.Spc(value); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { // Check to see if in direct mode if (!(tokenMarker.Token is FnToken)) { throw new Exceptions.SyntaxErrorException(); } var userDefinedFunctionNameToken = tokenMarker.GetNextToken(); if (!(userDefinedFunctionNameToken is VariableNameToken userDefinedNameToken)) { throw new Exceptions.SyntaxErrorException(); } if (userDefinedNameToken.VariableType != VariableValueType.RealNumber) { throw new Exceptions.TypeMismatchException(); } var openParenToken = tokenMarker.GetNextToken(); if (!(openParenToken is OpenParenToken)) { throw new Exceptions.SyntaxErrorException(); } var parameterToken = tokenMarker.GetNextToken(); if (!(parameterToken is VariableNameToken functionParameterToken)) { throw new Exceptions.SyntaxErrorException(); } var closeParenToken = tokenMarker.GetNextToken(); if (!(closeParenToken is CloseParenToken)) { throw new Exceptions.SyntaxErrorException(); } var equalsParenToken = tokenMarker.GetNextToken(); if (!(equalsParenToken is Operators.EqualToken)) { throw new Exceptions.SyntaxErrorException(); } List <Token> userDefinedFunctionTokens = new List <Token>(); while (tokenMarker.GetNextToken() != null) { userDefinedFunctionTokens.Add(tokenMarker.Token); } var userDefinedStatement = new Statement(userDefinedFunctionTokens); var userDefinedFunction = new Functions.UserDefinedFunction(functionParameterToken, userDefinedStatement); interpreter.VariablesEnvironment.CreateUserDefinedFunction(userDefinedNameToken, userDefinedFunction); }
public virtual void Execute(RetroBASIC.Interpreter interpreter, TokenMarker tokenMarker) { throw new NotImplementedException(); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { while (tokenMarker.Token != null) { ValueTokenArray indicies = null; if (!(tokenMarker.Token is VariableNameToken variableNameToken)) { throw new Exceptions.SyntaxErrorException(); } if (tokenMarker.PeekNext() is OpenParenToken) { indicies = interpreter.ExpressionEvaluator.EvaluateVariableArrayAssignment(tokenMarker); } else { tokenMarker.MoveNext(); } var valueToken = interpreter.ReadNextDataValue(); if (valueToken == null) { throw new Exceptions.OutOfDataException(); } switch (variableNameToken.VariableType) { case VariableValueType.String: break; case VariableValueType.RealNumber: float realValue = 0; var success = float.TryParse(((StringValueToken)valueToken).Value, out realValue); if (success == false) { throw new Exceptions.TypeMismatchException(); } valueToken = interpreter.TokensProvider.CreateRealValueToken(realValue); break; case VariableValueType.IntegerNumber: success = float.TryParse(((StringValueToken)valueToken).Value, out realValue); if (success == false) { throw new Exceptions.TypeMismatchException(); } // In Commodore BASIC, a READ of a number with a decimal into an integer number produces a zero. int intValue = (int)Math.Abs(realValue); if (realValue != intValue) { intValue = 0; } if (intValue < Int16.MinValue || intValue > Int16.MaxValue) { throw new Exceptions.OverflowException(); } valueToken = interpreter.TokensProvider.CreateIntegerValueToken((Int16)intValue); break; } interpreter.VariablesEnvironment.SetVariableValue(variableNameToken, indicies, valueToken); if (tokenMarker.Token == null) { break; } if (!(tokenMarker.Token is CommaToken)) { throw new Exceptions.SyntaxErrorException(); } tokenMarker.MoveNext(); // The next token should now be a variable name token } }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { throw new Exceptions.SyntaxErrorException(); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { interpreter.BreakDetected(); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { interpreter.DataStatementMarker.MoveTo(0); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { /* The REM command is just for comments. */ }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { throw new Exceptions.CommandNotSupportedException(); }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { // Nothing to see here. Move along. }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { if (interpreter.InterpreterMode == InterpreterMode.Immmediate) { throw new Exceptions.IllegalDirectModeException(); } var variableNameTokens = new List <(VariableNameToken, ValueTokenArray)>(); while (tokenMarker.Token != null) { ValueTokenArray indicies = null; if (!(tokenMarker.Token is VariableNameToken variableNameToken)) { throw new Exceptions.SyntaxErrorException(); } if (tokenMarker.PeekNext() is OpenParenToken) { indicies = interpreter.ExpressionEvaluator.EvaluateVariableArrayAssignment(tokenMarker); } else { tokenMarker.MoveNext(); } if (tokenMarker.Token != null && !(tokenMarker.Token is CommaToken)) { throw new Exceptions.SyntaxErrorException(); } variableNameTokens.Add((variableNameToken, indicies)); } foreach (var(nameToken, indicies) in variableNameTokens) { var input = interpreter.Console.ReadChar(); switch (nameToken.VariableType) { case VariableValueType.String: string inputString = (input != null) ? input.ToString() : string.Empty; interpreter.VariablesEnvironment.SetVariableValue(nameToken, indicies, interpreter.TokensProvider.CreateStringValueToken(inputString)); break; case VariableValueType.RealNumber: float realValue; if (input == null) { realValue = 0; } else { if (input >= '0' && input <= '9') { realValue = (float)(input - '0'); } else { throw new Exceptions.SyntaxErrorException(); } } interpreter.VariablesEnvironment.SetVariableValue(nameToken, indicies, interpreter.TokensProvider.CreateRealValueToken(realValue)); break; case VariableValueType.IntegerNumber: Int16 intValue; if (input == null) { intValue = 0; } else { if (input >= '0' && input <= '9') { intValue = (Int16)(input - '0'); } else { throw new Exceptions.SyntaxErrorException(); } } interpreter.VariablesEnvironment.SetVariableValue(nameToken, indicies, interpreter.TokensProvider.CreateIntegerValueToken(intValue)); break; } if (input == null) { Thread.Sleep(100); } } }
public override void Execute(Interpreter interpreter, TokenMarker tokenMarker) { // If used as a primary command, throw a syntax error exception. throw new Exceptions.SyntaxErrorException(); }