}//Need Test protected void WhileSentense() { int begin = CurrentPosition; Eat(TokenType.WHILE); Eat(TokenType.L_PAR); ValueToken result = Expression(); Eat(TokenType.R_PAR); if (result is BoolToken) { if ((result as BoolToken).GetValue) { Sentense(); CurrentPosition = begin; WhileSentense(); } else { if (CurrentToken.GetTokenType == TokenType.L_FIGURE) { SkipBlock(); } else { SkipSentense(); } } } else { Error(); } }//Need Test
private void Compile(List <Token.Token> tokens) { // determine first image id foreach (var token in tokens) { if (token is ImageToken itoken) { firstImageId = itoken.Id; break; } } // determine final token tokens = MarkovProcess.Run(GetRules(), tokens); if (tokens.Count != 1) { throw new Exception("Could not resolve all tokens to an expression"); } if (tokens[0].TokenType != Token.Token.Type.Value) { throw new Exception("Please enter a valid formula"); } finalToken = (ValueToken)tokens[0]; }
public override ValueToken Evaluate(RetroBASIC.Interpreter interpreter, ValueToken item1, ValueToken item2) { StringValueToken string1Token = item1 as StringValueToken; StringValueToken string2Token = item2 as StringValueToken; if (string1Token != null && string2Token != null) { var newString = string1Token.Value + string2Token.Value; if (newString.Length >= 256) { throw new Exceptions.StringTooLongException(); } return(interpreter.TokensProvider.CreateStringValueToken(newString)); } var number1Token = item1 as NumericValueToken; var number2Token = item2 as NumericValueToken; if (number1Token == null || number2Token == null) { throw new Exceptions.TypeMismatchException(); } var newNumber = number1Token.RealValue + number2Token.RealValue; return(interpreter.TokensProvider.CreateRealValueToken(newNumber)); }
public Evaluation EvaluateOperator( ExpressionOptions options, ValueToken op, Token?left, Token?right) { var validationError = ValidateOperatorTokens(options, op, left, right); if (validationError != null) { return(validationError); } var leftEval = left != null?Evaluate(options, left) : null; if (leftEval?.Error != null) { return(leftEval); } var rightEval = right != null?Evaluate(options, right) : null; if (rightEval?.Error != null) { return(rightEval); } return(ExecuteOperator.Invoke(op.Value, leftEval?.Result, rightEval?.Result)); }
//--------------------------------------------------------------------- public void Visit(ValueToken valueToken) { var expr = new ConstantExpression(valueToken); _expressionStack.Push(expr); _lastToken = valueToken; }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken item1, ValueToken item2) { int result; if (item1 is NumericValueToken numericToken1 && item2 is NumericValueToken numericToken2) { result = (numericToken1.RealValue == numericToken2.RealValue) ? Constants.TRUE : Constants.FALSE; }
//--------------------------------------------------------------------- internal static ParsingException ValueFollowedByValue(ValueToken lastToken, ValueToken valueToken) { string msg = $"Value {valueToken.Value} at position {valueToken.Position} can't follow value {lastToken.Value} at position {lastToken.Position}." + "\nAre you missing an operation?"; return(new ParsingException(msg)); }
private bool ValidateOperatorList( ExpressionOptions options, List <Token> tokens, [MaybeNullWhen(false)] out ValueToken opToken, out Token?leftToken, out Token?rightToken) { if (tokens.Count == 2) { for (int opIndex = 0; opIndex < tokens.Count; opIndex++) { var token = tokens[opIndex]; if (token.Type != TokenType.Operator) { continue; } var opDefinitions = options.OpDefinitions.Span; for (int j = 0; j < opDefinitions.Length; j++) { var opDef = opDefinitions[j]; if (opDef.Associativity == OperatorSidedness.Both) { continue; } opToken = (ValueToken)token; for (int k = 0; k < opDef.Names.Length; k++) { var name = opDef.Names[k]; if (!name.Span.SequenceEqual(opToken.Value)) { continue; } leftToken = opIndex == 0 ? null : tokens[0]; rightToken = opIndex == 1 ? null : tokens[1]; return(true); } } break; } } if (tokens.Count == 3 && tokens[1] is ValueToken middleToken && middleToken.Type == TokenType.Operator) { opToken = middleToken; leftToken = tokens[0]; rightToken = tokens[2]; return(true); } opToken = null; leftToken = null; rightToken = null; return(false); }
private Token() { type = TokenType.TOKEN_NONE; value = new ValueToken(); value.from = 0.0f; value.to = 0.0f; value.number = 0.0f; list = new List <float>(); }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken item1, ValueToken item2) { int result; if (item1 is StringValueToken stringToken1 && item2 is StringValueToken stringToken2) { int compareResult = StringComparer.OrdinalIgnoreCase.Compare(stringToken1.Value, stringToken2.Value); result = (compareResult != 0) ? Constants.TRUE : Constants.FALSE; }
public void Digits___OK([Values("2", "3.14", "-1", "3e2", "-3e4", "1E2", "1_000", "2_000_000")] string expression) { Lexer sut = this.CreateSut(expression); ValueToken actual = sut.ReadTokens() .Cast <ValueToken>() .Single(); Assert.AreEqual(double.Parse(expression.Replace("_", "")), actual.Value); }
private ValueToken ValueToken(StringBuilder builder, int index) { ValueToken vt = new ValueToken(); vt.Value = builder.ToString(); vt.Index = index - vt.Value.Length; vt.Length = vt.Value.Length; return(vt); }
void SetStringValue(VariableNameToken nameToken, ValueToken valueToken) { if (valueToken is StringValueToken stringToken) { stringVariables[nameToken.Name] = stringToken; return; } throw new Exceptions.TypeMismatchException(); }
//--------------------------------------------------------------------- public void Visit(ValueToken valueToken) { this.CheckIntrinsic(valueToken); if (_lastToken is ValueToken) { throw ParsingException.ValueFollowedByValue(_lastToken as ValueToken, valueToken); } _lastToken = valueToken; }
public void AddValue(IValueToken valueToken) { if (valueToken is ValueToken value) { this.valueToken = value; } else { throw new ArgumentException(); } }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken item1, ValueToken item2) { if (item1 is StringValueToken) { throw new Exceptions.TypeMismatchException(); } var number1Token = (NumericValueToken)item1; var number2Token = (NumericValueToken)item2; return(interpreter.TokensProvider.CreateRealValueToken(number1Token.RealValue - number2Token.RealValue)); }
public override void VisitFieldToken(string fieldName, ValueToken value, BlittableJsonReaderObject parameters) { if (fieldName != Constants.Documents.Indexing.Fields.DocumentIdFieldName) { return; } var id = QueryBuilder.GetValue(Constants.Documents.Indexing.Fields.DocumentIdFieldName, _query, _metadata, parameters, value); Debug.Assert(id.Type == ValueTokenType.String); AddId(id.Value.ToString()); }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken item1, ValueToken item2) { if (item1 is IntegerValueToken value) { return(interpreter.TokensProvider.CreateIntegerValueToken(-value.Value)); } if (item1 is RealValueToken realValue) { return(interpreter.TokensProvider.CreateRealValueToken(-realValue.Value)); } throw new Exceptions.TypeMismatchException(); }
// Finish evaluating a function of the form FUNC(param1, ...) ValueToken EvaluateFunctionToken(Token token) { var functionToken = (FunctionToken)token; // Pop the arguments off the stack. The number of arguments to pass // is stored its own stack. var argsCount = arrayCount.Pop(); var args = new ValueToken[argsCount]; // Check for the correct number of arguments if ((argsCount < functionToken.RequiredArgsCount) || (argsCount > (functionToken.RequiredArgsCount + functionToken.OptionalArgsCount))) { throw new Exceptions.SyntaxErrorException(); } // Arguments come off the stack in reverse order, // so it's easier to populate the array in reverse order too. int argsIndex = argsCount; while (argsIndex > 0) { argsIndex -= 1; var arg = valueTokens.Pop(); args[argsIndex] = arg; } // Type check the arguments for (int i = 0; i < argsCount; i++) { if ((functionToken.ArgumentFlags[i] & FunctionArgumentFlags.Number) != 0) { if (!(args[i] is NumericValueToken)) { throw new Exceptions.TypeMismatchException(); } } else // Assume a string expression { if (args[i] is NumericValueToken) { throw new Exceptions.TypeMismatchException(); } } } var result = functionToken.Evaluate(interpreter, args); return(result); }
private static ResultCode MakeImplicitMultiplications( ExpressionOptions options, List <Token> tokens) { for (int i = 0; i < tokens.Count; i++) { var token = tokens[i]; if (token is CollectionToken collectionToken) { var code = MakeImplicitMultiplications(options, collectionToken.Children); if (code != ResultCode.Ok) { return(code); } } else if (token.Type != TokenType.Name) { // Skip as this type is not allowed to have an implicit factor prefix. continue; } if (i - 1 < 0) { continue; // We are at the list's beginning. } var leftToken = tokens[i - 1]; if (leftToken.Type == TokenType.Operator || leftToken.Type == TokenType.Name || leftToken.Type == TokenType.ListSeparator) { continue; } if (leftToken.Type != TokenType.DecimalDigit && leftToken.Type != TokenType.DecimalNumber && leftToken.Type != TokenType.List) { return(ResultCode.InvalidTokenBeforeList); } var multiplyOpDef = options.GetOperatorDefinition(OperatorType.Multiply); if (multiplyOpDef == null) { return(ResultCode.MissingMultiplicationDefinition); } var opToken = new ValueToken(TokenType.Operator, multiplyOpDef.Names[0]); tokens.Insert(i, opToken); } return(ResultCode.Ok); }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken item1, ValueToken item2) { if (item1 is StringValueToken) { throw new Exceptions.TypeMismatchException(); } var number1Token = (NumericValueToken)item1; var number2Token = (NumericValueToken)item2; var result = Math.Pow(number1Token.RealValue, number2Token.RealValue); return(new RealValueToken(result)); }
public override ValueToken Evaluate(Interpreter interpreter, ValueToken item1, ValueToken item2) { if (item1 is StringValueToken) { throw new Exceptions.TypeMismatchException(); } var numberToken1 = (NumericValueToken)item1; var numberToken2 = (NumericValueToken)item2; var result = numberToken1.IntValue | numberToken2.IntValue; return(new RealValueToken(result)); }
}//Done protected ValueToken Fact() { ValueToken result = null; if (CurrentToken is ValueToken) { result = CurrentToken as ValueToken; Eat(CurrentToken.GetTokenType); } else if (CurrentToken.GetTokenType == TokenType.ID) { if (Variables.ContainsKey((CurrentToken as IDToken).GetName)) { result = Variables[(CurrentToken as IDToken).GetName]; } else { Error("Error: Variable is not declarated"); } Eat(TokenType.ID); } else if (CurrentToken.GetTokenType == TokenType.BOOL_TRUE) { Eat(TokenType.BOOL_TRUE); return(new BoolToken(true)); } else if (CurrentToken.GetTokenType == TokenType.BOOL_FALSE) { return(new BoolToken(false)); } else if (CurrentToken.GetTokenType == TokenType.L_PAR) { Eat(TokenType.L_PAR); result = Expression(); Eat(TokenType.R_PAR); } else if (CurrentToken.GetTokenType == TokenType.READ_FUNCTION) { return(ReadFunction()); } else { Error("Error : unexpected token"); } return(result); }//unDone, need builtInFunctions
public void SetVariableValue(VariableNameToken variableNameToken, ValueToken value) { switch (variableNameToken.VariableType) { case VariableValueType.String: SetStringValue(variableNameToken, value); break; case VariableValueType.RealNumber: SetRealNumberValue(variableNameToken, value); break; case VariableValueType.IntegerNumber: SetIntegerNumberValue(variableNameToken, value); break; } }
public override string ToString() { if (NameToken != null && ValueToken != null) { return(String.Format(CultureInfo.CurrentCulture, "{0} = {1}", NameToken.ToString(), ValueToken.ToString())); } else if (NameToken != null) { return(NameToken.ToString()); } else if (ValueToken != null) { return(ValueToken.ToString()); } return("?"); }
public void Shift(int offset) { if (NameToken != null) { NameToken.Shift(offset); } if (EqualsSign >= 0) { EqualsSign += offset; } if (ValueToken != null) { ValueToken.Shift(offset); } }
private static bool CheckDeclarationSemantic(StatementToken statement, List <ObjectDescription> descriptions) { ValueToken valueToken = statement.DeclarationToken.ValueToken; List <ObjectPropertyToken> properties = (List <ObjectPropertyToken>)valueToken.Value; VarType objectType = valueToken.Type; if (ProgramContextHolder.GetInstance().Variables.Where(p => string.Equals(p.Name, statement.DeclarationToken.IdentifierToken.Value)).ToList().Count == 0) { MyVariable variable = new MyVariable(statement.DeclarationToken.IdentifierToken.Value, objectType, valueToken); ProgramContextHolder.GetInstance().Variables.Add(variable); } else { throw new Exception("VARIABLE WITH NAME : " + "\" " + statement.DeclarationToken.IdentifierToken.Value + " \" WAS DECLARED"); } for (int field = 0; field < descriptions.Count; field++) { if (descriptions[field].ObjectType == objectType) { ObjectDescription objectDescription = descriptions[field]; for (int i = 0; i < properties.Count; i++) { ObjectField objectField = new ObjectField(properties[i].IdentifierToken.Value, properties[i].Value.Type); if (objectDescription.ObjectsFields.Contains(objectField)) { Console.WriteLine(properties[i].IdentifierToken.Value + " " + properties[i].Value.Type + " correct field"); } else { throw new Exception("Not existed field type in \"" + objectField.Name + "\" according to the :" + objectDescription.ObjectType.ToString() + " structure"); } } break; } } return(true); }
void SetRealNumberValue(VariableNameToken nameToken, ValueToken valueToken) { if (valueToken is StringValueToken) { throw new Exceptions.TypeMismatchException(); } var numberToken = (NumericValueToken)valueToken; if (numberToken is RealValueToken realToken) { realNumberVariables[nameToken.Name] = realToken; } else { realNumberVariables[nameToken.Name] = new RealValueToken(numberToken.RealValue); } }
private decimal CalculateTokens(List <Token> outputTokens) { while (outputTokens.Count > 1) { int operatorIndex = outputTokens.FindIndex(token => token is OperationToken); OperationToken operationToken = outputTokens[operatorIndex] as OperationToken; ValueToken leftValueToken = outputTokens[operatorIndex - 2] as ValueToken; ValueToken rightValueToken = outputTokens[operatorIndex - 1] as ValueToken; outputTokens.RemoveAt(operatorIndex); outputTokens.RemoveAt(operatorIndex - 1); decimal result = DoOperation(leftValueToken.Value, rightValueToken.Value, operationToken.Operation); leftValueToken.Value = result; } return((outputTokens[0] as ValueToken).Value); }
}//Done protected ValueToken ConOp() { ValueToken left = CompareOps(); while (CurrentToken.GetTokenType == TokenType.CON) { Eat(TokenType.CON); ValueToken right = CompareOps(); if ((left is BoolToken) && (right is BoolToken)) { left = (left as BoolToken) & (right as BoolToken); } else { Error("Error in ConOp: one of the values are not Bool type"); } } return(left); }//Done
public ParserState AddLocal(string name, ValueToken value) => new ParserState(Clusters, Locals.Add(name,value));
/// <summary> /// Processes ByMonth= and ByMonthDay= attribute entries /// </summary> /// <param name="entry"></param> /// <param name="value"></param> /// <param name="minValue"></param> /// <param name="maxValue"></param> /// <param name="tkn"></param> /// <returns></returns> private int[] ProcessByIntValues(CalendarEntry entry, string value, int minValue, int maxValue, ValueToken tkn) { string[] byValues = value.Split(','); if (byValues.Length > 0) { int[] byIntValues = new int[byValues.Length]; for (int i = 0; i < byValues.Length; i++) { int n; if (int.TryParse(byValues[i], out n) == false) { ReportError(entry, String.Format("\"{0}\" is not a valid Integer value", byValues[i])); n = minValue; } else { int absn = Math.Abs(n); if (absn < minValue || absn > maxValue) { ReportError(entry, String.Format( "{0} value ({1}) is not in the range +/- {2} to {3}", n, _values[(int) tkn].Text.ToUpper(), minValue, maxValue)); break; } } byIntValues[i] = n; } return (byIntValues); } return (null); }