private static FormulaValue RunAggregator(IAggregator agg, EvalVisitor runner, SymbolContext context, IRContext irContext, FormulaValue[] args)
{
var arg0 = (TableValue)args[0];
var arg1 = (LambdaFormulaValue)args[1];
foreach (DValue <RecordValue> row in arg0.Rows)
{
if (row.IsValue)
{
var childContext = context.WithScopeValues(row.Value);
var value = arg1.Eval(runner, childContext);
if (value is NumberValue number)
{
value = FiniteChecker(irContext, 0, number);
}
if (value is ErrorValue error)
{
return(error);
}
agg.Apply(value);
}
}
return(agg.GetResult(irContext));
}
private static IEnumerable <DValue <RecordValue> > LazyAddColumns(EvalVisitor runner, SymbolContext context, IEnumerable <DValue <RecordValue> > sources, IRContext recordIRContext, NamedLambda[] newColumns)
{
foreach (var row in sources)
{
if (row.IsValue)
{
// $$$ this is super inefficient... maybe a custom derived RecordValue?
var fields = new List <NamedValue>(row.Value.Fields);
var childContext = context.WithScopeValues(row.Value);
foreach (var column in newColumns)
{
var value = column.Lambda.Eval(runner, childContext);
fields.Add(new NamedValue(column.Name, value));
}
yield return(DValue <RecordValue> .Of(new InMemoryRecordValue(recordIRContext, fields.ToArray())));
}
else
{
yield return(row);
}
}
}
private static IEnumerable <DValue <RecordValue> > LazyFilter(EvalVisitor runner,
SymbolContext context,
IEnumerable <DValue <RecordValue> > sources,
LambdaFormulaValue filter)
{
foreach (var row in sources)
{
if (row.IsValue)
{
var childContext = context.WithScopeValues(row.Value);
// Filter evals to a boolean
var result = filter.Eval(runner, childContext);
bool include = false;
if (result is BooleanValue booleanValue)
{
include = booleanValue.Value;
}
if (include)
{
yield return(row);
}
}
}
}
public static FormulaValue Today(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
// $$$ timezone?
var date = DateTime.Today;
return(new DateValue(irContext, date));
}
// https://docs.microsoft.com/en-us/powerapps/maker/canvas-apps/functions/function-text
public static FormulaValue Text(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
// only DateValue and DateTimeValue are supported for now with custom format strings.
if (args.Length > 1 && args[0] is StringValue)
{
return(CommonErrors.NotYetImplementedError(irContext, "Text() doesn't support format args for type StringValue"));
}
string resultString = null;
string formatString = null;
if (args.Length > 1 && args[1] is StringValue fs)
{
formatString = fs.Value;
}
CultureInfo suppliedCulture = null;
if (args.Length > 2 && args[2] is StringValue locale)
{
suppliedCulture = new CultureInfo(locale.Value);
}
switch (args[0])
{
case NumberValue num:
resultString = num.Value.ToString(formatString ?? "g", suppliedCulture ?? runner.CultureInfo);
break;
case StringValue s:
resultString = s.Value;
break;
case DateValue d:
formatString = ExpandDateTimeFormatSpecifiers(formatString, suppliedCulture ?? runner.CultureInfo);
resultString = d.Value.ToString(formatString ?? "M/d/yyyy", suppliedCulture ?? runner.CultureInfo);
break;
case DateTimeValue dt:
formatString = ExpandDateTimeFormatSpecifiers(formatString, suppliedCulture ?? runner.CultureInfo);
resultString = dt.Value.ToString(formatString ?? "g", suppliedCulture ?? runner.CultureInfo);
break;
case TimeValue t:
formatString = ExpandDateTimeFormatSpecifiers(formatString, suppliedCulture ?? runner.CultureInfo);
resultString = _epoch.Add(t.Value).ToString(formatString ?? "t", suppliedCulture ?? runner.CultureInfo);
break;
default:
break;
}
if (resultString != null)
{
return(new StringValue(irContext, resultString));
}
return(CommonErrors.NotYetImplementedError(irContext, $"Text format for {args[0]?.GetType().Name}"));
}
public void Init()
{
lexer = new Lexer(inStream);
parser = new RavParser();
visitor = new EvalVisitor();
env = new Natives().Enviroment(new NestedEnv());
}
private void runBtn_Click(object sender, EventArgs e)
{
consoleText.Clear();
Lexer lexer = new Lexer(new StringReader(codeText.Text));
RavParser parser = new RavParser();
EvalVisitor visitor = new EvalVisitor();
visitor.DebugOption = false;
IEnvironment env = new Natives().Enviroment(new NestedEnv());
try {
while (lexer.Peek(0) != Token.EOF)
{
ASTree ast = parser.Parse(lexer);
//System.Console.WriteLine(" >>> " + ast.GetType().ToString() + " " + ast.ToString());
//consoleText.AppendText("> " + ast.ToString() + "\n");
ast.Accept(visitor, env);
consoleText.AppendText("> " + visitor.Result.ToString() + "\n");
}
}
catch (ParseException ex) {
consoleText.AppendText("> " + ex.Message + "\n");
}
/*
* for (Token tok = lexer.Read(); tok != Token.EOF; tok = lexer.Read()) {
* consoleText.AppendText("> " + tok.Text + "\n");
* }
*/
}
public void partial_evaluation_with_variables(string text, string simplified)
{
var visitor = new EvalVisitor(name => name == "X" ? 5.0 : (double?)null);
Node n = new Analyser().Analyse(new StringTokenizer(text));
var s = visitor.VisitNode(n);
Assert.That(s.ToString(), Is.EqualTo(simplified));
}
public void test_evaluation(string text, double expectedResult)
{
Node n = new Analyser().Analyse(new StringTokenizer(text));
EvalVisitor visitor = new EvalVisitor();
var c = (ConstantNode)visitor.VisitNode(n);
Assert.That(c.Value, Is.EqualTo(expectedResult));
}
// https://docs.microsoft.com/en-us/powerapps/maker/canvas-apps/functions/function-value
// Convert string to number
public static FormulaValue Value(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
var arg0 = args[0];
if (arg0 is NumberValue n)
{
return(n);
}
if (arg0 is DateValue dv)
{
return(DateToNumber(irContext, new DateValue[] { dv }));
}
if (arg0 is DateTimeValue dtv)
{
return(DateTimeToNumber(irContext, new DateTimeValue[] { dtv }));
}
var str = ((StringValue)arg0).Value.Trim();
var styles = NumberStyles.Any;
if (string.IsNullOrEmpty(str))
{
return(new BlankValue(irContext));
}
double div = 1;
if (str[str.Length - 1] == '%')
{
str = str.Substring(0, str.Length - 1);
div = 100;
styles = NumberStyles.Number;
}
else if (str[0] == '%')
{
str = str.Substring(1, str.Length - 1);
div = 100;
styles = NumberStyles.Number;
}
if (!double.TryParse(str, styles, runner.CultureInfo, out var val))
{
return(CommonErrors.InvalidNumberFormatError(irContext));
}
if (IsInvalidDouble(val))
{
return(CommonErrors.ArgumentOutOfRange(irContext));
}
val /= div;
return(new NumberValue(irContext, val));
}
public static bool Eval(Bits bits, Dictionary <Expr, int> exprMap, Expr e)
{
var v = new EvalVisitor {
bits = bits,
exprMap = exprMap,
};
v.Visit(e);
return(v.stack.Pop());
}
public void test_evaluation(string text, double expectedResult)
{
Node n = new Analyser().Analyse(new StringTokenizer(text));
EvalVisitor visitor = new EvalVisitor();
visitor.VisitNode(n);
double result = visitor.Result;
Assert.That(result, Is.EqualTo(expectedResult));
}
// Average([1,2,3], Value * Value)
public static FormulaValue AverageTable(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
var arg0 = (TableValue)args[0];
if (arg0.Rows.Count() == 0)
{
return(CommonErrors.DivByZeroError(irContext));
}
return(RunAggregator(new AverageAgg(), runner, symbolContext, irContext, args));
}
public static FormulaValue Split(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, StringValue[] args)
{
var text = args[0].Value;
var separator = args[1].Value;
// The separator can be zero, one, or more characters that are matched as a whole in the text string. Using a zero length or blank
// string results in each character being broken out individually.
var substrings = string.IsNullOrEmpty(separator) ? text.Select(c => new string(c, 1)) : text.Split(new string[] { separator }, StringSplitOptions.None);
var rows = substrings.Select(s => new StringValue(IRContext.NotInSource(FormulaType.String), s));
return(new InMemoryTableValue(irContext, StandardSingleColumnTableFromValues(irContext, rows.ToArray(), BuiltinFunction.OneColumnTableResultName)));
}
// Create new table
public static FormulaValue AddColumns(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
var sourceArg = (TableValue)args[0];
var newColumns = NamedLambda.Parse(args);
var tableType = (TableType)irContext.ResultType;
var recordIRContext = new IRContext(irContext.SourceContext, tableType.ToRecord());
var rows = LazyAddColumns(runner, symbolContext, sourceArg.Rows, recordIRContext, newColumns);
return(new InMemoryTableValue(irContext, rows));
}
public static FormulaValue SortTable(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
var arg0 = (TableValue)args[0];
var arg1 = (LambdaFormulaValue)args[1];
var arg2 = (StringValue)args[2];
var pairs = arg0.Rows.Select(row =>
{
if (row.IsValue)
{
var childContext = symbolContext.WithScopeValues(row.Value);
return(new KeyValuePair <DValue <RecordValue>, FormulaValue>(row, arg1.Eval(runner, childContext)));
}
return(new KeyValuePair <DValue <RecordValue>, FormulaValue>(row, row.ToFormulaValue()));
}).ToList();
var errors = new List <ErrorValue>(pairs.Select(pair => pair.Value).OfType <ErrorValue>());
var allNumbers = pairs.All(pair => IsValueTypeErrorOrBlank <NumberValue>(pair.Value));
var allStrings = pairs.All(pair => IsValueTypeErrorOrBlank <StringValue>(pair.Value));
var allBooleans = pairs.All(pair => IsValueTypeErrorOrBlank <BooleanValue>(pair.Value));
if (!(allNumbers || allStrings || allBooleans))
{
errors.Add(CommonErrors.RuntimeTypeMismatch(irContext));
return(ErrorValue.Combine(irContext, errors));
}
if (errors.Count != 0)
{
return(ErrorValue.Combine(irContext, errors));
}
var compareToResultModifier = 1;
if (arg2.Value.ToLower() == "descending")
{
compareToResultModifier = -1;
}
if (allNumbers)
{
return(SortValueType <NumberValue, double>(pairs, irContext, compareToResultModifier));
}
else if (allStrings)
{
return(SortValueType <StringValue, string>(pairs, irContext, compareToResultModifier));
}
else
{
return(SortValueType <BooleanValue, bool>(pairs, irContext, compareToResultModifier));
}
}
private void EvaluateTape(double[] arg)
{
for (int i = 0; i < Dimension; ++i)
{
tape[i].Value = arg[i];
}
var evalVisitor = new EvalVisitor(tape);
for (int i = Dimension; i < tape.Length; ++i)
{
tape[i].Accept(evalVisitor);
}
}
public static FormulaValue TimeParse(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, StringValue[] args)
{
var str = args[0].Value;
if (TimeSpan.TryParse(str, runner.CultureInfo, out TimeSpan result))
{
return(new TimeValue(irContext, result));
}
else
{
return(CommonErrors.InvalidDateTimeError(irContext));
}
}
public static FormulaValue DateParse(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, StringValue[] args)
{
var str = args[0].Value;
if (DateTime.TryParse(str, runner.CultureInfo, DateTimeStyles.None, out DateTime result))
{
return(new DateValue(irContext, result.Date));
}
else
{
return(CommonErrors.InvalidDateTimeError(irContext));
}
}
public void with_variables(string text, double expectedResult)
{
Dictionary <string, double> vars = new Dictionary <string, double>();
vars.Add("X", 5);
vars.Add("Y", 7);
var visitor = new EvalVisitor(vars);
Node n = new Analyser().Analyse(new StringTokenizer(text));
var c = (ConstantNode)visitor.VisitNode(n);
Assert.That(c.Value, Is.EqualTo(expectedResult));
}
public IList <User> Getusers(User user)
{
var userAsDictionary = ObjectToDictionaryHelper.ToDictionary(user) as Dictionary <string, dynamic>;
IVisitor <User> v = new EvalVisitor <User>(filter);
var iterator = userAsDictionary.GetEnumerator();
while (iterator.MoveNext())
{
v.visit(iterator.Current.Key, iterator.Current.Value);
}
return(repository.GetUsers(filter));
}
public void test_evaluation_with_var(string text, double expectedResult)
{
Node n = new Analyser().Analyse(new StringTokenizer(text));
VariableSetVisitor setVisitor = new VariableSetVisitor();
setVisitor.SetVariable(n, "a", 3.0);
EvalVisitor visitor = new EvalVisitor();
visitor.VisitNode(n);
double result = visitor.Result;
Assert.That(result, Is.EqualTo(expectedResult));
}
public StringBuilder Compile()
{
Scope scope = new Scope(mainScope);
SinumerikParser mainParser = new SinumerikParser(new CommonTokenStream(mainLexer), null, _errorTextWriter);
mainParser.BuildParseTree = true;
IParseTree mainTree = mainParser.parse();
// outputTextWriter.Close();
SymbolVisitor mainSymbolVisitor = new SymbolVisitor(functions);
mainSymbolVisitor.Visit(mainTree);
EvalVisitor visitor = new EvalVisitor(scope, functions, _gcodeOutput);
visitor.Visit(mainTree);
return(_gcodeOutput);
}
public void test_evaluation(string text, double expectedResult)
{
Node n1 = new Analyser().Analyse(new StringTokenizer(text));
Node n2 = new Analyser().Analyse(new StringTokenizer(text));
MutationVisitor mutationVisitor = new MutationVisitor(mutationRate: 1);
mutationVisitor.Mutate(ref n2);
EvalVisitor visitor = new EvalVisitor();
visitor.VisitNode(n1);
double result1 = visitor.Result;
visitor.VisitNode(n2);
double result2 = visitor.Result;
Assert.That(result1, Is.Not.EqualTo(result2));
}
public static void Main()
{
Console.Write("> ");
var line = Console.ReadLine();
var parser = new Parser(new Scanner(line).Start().GetEnumerator());
try {
var tree = parser.Prog();
var resultEval = new EvalVisitor().Visit((dynamic)tree);
var resultLisp = new LispVisitor().Visit((dynamic)tree);
var resultC = new CVisitor().Visit((dynamic)tree);
Console.WriteLine(tree.ToStringTree());
Console.WriteLine(resultEval);
Console.WriteLine(resultLisp);
Console.WriteLine(resultC);
} catch (SyntaxError) {
Console.Error.WriteLine("Found syntax error!");
}
}
public void test_evaluation(string text, string text2)
{
Node n = new Analyser().Analyse(new StringTokenizer(text));
Node n2 = new Analyser().Analyse(new StringTokenizer(text2));
Random r = new Random(7);
SwapGenomeVisitor genomeSwapper = new SwapGenomeVisitor();
Node n3 = genomeSwapper.SwapGenome(n, n2, r.Next(n.Count), r.Next(n2.Count));
EvalVisitor visitor = new EvalVisitor();
visitor.VisitNode(n2);
double result = visitor.Result;
visitor.VisitNode(n3);
double resultBase = visitor.Result;
Assert.That(result, Is.Not.EqualTo(resultBase));
}
public static FormulaValue CountIf(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
// Streaming
var sources = (TableValue)args[0];
var filter = (LambdaFormulaValue)args[1];
int count = 0;
var errors = new List <ErrorValue>();
foreach (var row in sources.Rows)
{
if (row.IsValue)
{
var childContext = symbolContext.WithScopeValues(row.Value);
var result = filter.Eval(runner, childContext);
if (result is ErrorValue error)
{
errors.Add(error);
continue;
}
bool include = ((BooleanValue)result).Value;
if (include)
{
count++;
}
}
if (row.IsError)
{
errors.Add(row.Error);
}
}
if (errors.Count != 0)
{
return(ErrorValue.Combine(irContext, errors));
}
return(new NumberValue(irContext, count));
}
public SLValue Invoke(String functionName, List <ExpressionContext> param, int countArgs, Dictionary <String, Function> functions, Scope scope, StringBuilder gcodeBuffer)
{
if (countArgs != this._param.Count)
{
throw new Exception("Illegal Function call");
}
Scope scopeNext = new Scope(null); // create function scope
EvalVisitor evalVisitor = new EvalVisitor(scope, functions, null);
for (int i = 0; i < param.Count; i++)
{
if (param[i].ChildCount > 0)
{
SLValue value = evalVisitor.Visit(param[i]);
scopeNext.assignParam(this._param[i].GetText(), value);
}
else
{
SLValue value = scopeNext.GetDefaultValue(this._paramType[i].GetText());
scopeNext.assignParam(this._param[i].GetText(), value);
}
}
EvalVisitor evalVistorNext = new EvalVisitor(scopeNext, functions, gcodeBuffer);
SLValue ret = SLValue.VOID;
try
{
evalVistorNext.Visit(this.block);
}
catch (ReturnValue returnValue)
{
ret = returnValue.value;
}
catch (Exception ex)
{
throw new Exception($"Illegal Function {functionName} call");
}
return(ret);
}
// Filter ([1,2,3,4,5], Value > 5)
public static FormulaValue FilterTable(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
// Streaming
var arg0 = (TableValue)args[0];
var arg1 = (LambdaFormulaValue)args[1];
if (args.Length > 2)
{
return(new ErrorValue(irContext, new ExpressionError()
{
Message = "Filter() only supports one predicate",
Span = irContext.SourceContext,
Kind = ErrorKind.Validation
}));
}
var rows = LazyFilter(runner, symbolContext, arg0.Rows, arg1);
return(new InMemoryTableValue(irContext, rows));
}
// Lazy evaluation
public static FormulaValue Or(EvalVisitor runner, SymbolContext symbolContext, IRContext irContext, FormulaValue[] args)
{
foreach (var arg in args)
{
var res = runner.EvalArg <BooleanValue>(arg, symbolContext, arg.IRContext);
if (res.IsValue)
{
var val = res.Value;
if (val.Value)
{
return(new BooleanValue(irContext, true));
}
}
else if (res.IsError)
{
return(res.Error);
}
}
return(new BooleanValue(irContext, false));
}
