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