public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var valueExpr = ValueExpression.Optimize(env, givens);
var innerExpr = InnerExpression.Optimize(env.DeclareVariable(VariableName, valueExpr is SucoConstant c ? c.Value : null), givens);
return(innerExpr is SucoConstant ? innerExpr : new SucoLetExpression(StartIndex, EndIndex, VariableName, valueExpr, innerExpr, Type));
}
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var optimized = Expression.Optimize(env, givens);
return(optimized is SucoConstant c
? new SucoConstant(StartIndex, EndIndex, Type, optimized.Type.InterpretImplicitConversionTo(Type, c.Value))
: new SucoImplicitConversionExpression(StartIndex, EndIndex, optimized, Type));
}
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var optimizedOperand = Operand.Optimize(env, givens);
return(optimizedOperand is SucoConstant c
? new SucoConstant(StartIndex, EndIndex, Type, Operand.Type.InterpretUnaryOperator(Operator, c))
: new SucoUnaryOperatorExpression(StartIndex, EndIndex, optimizedOperand, Operator, Type));
}
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var left = Left.Optimize(env, givens);
var right = Right.Optimize(env, givens);
return(left is SucoConstant cl && right is SucoConstant cr
? new SucoConstant(StartIndex, EndIndex, Type, left.Type.InterpretBinaryOperator(cl.Value, Operator, right.Type, cr.Value))
: new SucoBinaryOperatorExpression(StartIndex, EndIndex, left, right, Operator, Type));
}
public SucoEnvironment DecodeValues(string variablesJson)
{
if (_valuesCache == null || _valuesCacheVariables != variablesJson)
{
_valuesCacheVariables = variablesJson;
_valuesCache = ZingaUtil.ConvertVariableValues(JsonDict.Parse(variablesJson), JsonDict.Parse(ValuesJson));
}
return(_valuesCache);
}
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var conditionOpt = Condition.Optimize(env, givens);
if (conditionOpt is SucoConstant c)
{
return(c.Equals(true) ? True.Optimize(env, givens) : False.Optimize(env, givens));
}
return(new SucoConditionalExpression(StartIndex, EndIndex, conditionOpt, True.Optimize(env, givens), False.Optimize(env, givens), Type));
}
public override object Interpret(SucoEnvironment env, int?[] grid)
{
try
{
return(env.GetValue(Name));
}
catch (SucoTempCompileException tce)
{
throw new SucoCompileException(tce.Message, StartIndex, EndIndex);
}
}
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var optimizedOperand = Operand.Optimize(env, givens);
if (optimizedOperand is SucoConstant c)
{
var val = optimizedOperand.Type.InterpretMemberAccess(MemberName, c.Value, env, givens);
if (val != null)
{
return(new SucoConstant(StartIndex, EndIndex, Type, val));
}
}
return(new SucoMemberAccessExpression(StartIndex, EndIndex, optimizedOperand, MemberName, Type));
}
public override object Interpret(SucoEnvironment env, int?[] grid) => InnerExpression.Interpret(env.DeclareVariable(VariableName, ValueExpression.Interpret(env, grid)), grid);
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens)
{
var val = env.GetValue(Name);
return(val == null ? this : new SucoConstant(StartIndex, EndIndex, Type, val));
}
public override object Interpret(SucoEnvironment env, int?[] grid)
{
var result = Condition.Interpret(env, grid);
return(result == null ? null : (bool)result ? True.Interpret(env, grid) : False.Interpret(env, grid));
}
public override bool?Interpret(SucoEnvironment env, int?[] grid) => (bool?)Expression.Interpret(env, grid);
public override object Optimize(SucoEnvironment env, int?[] givens) => (bool?)(Expression.Optimize(env, givens) as SucoConstant)?.Value;
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens) => new SucoConstant(StartIndex, EndIndex, SucoType.Boolean, LiteralValue);
public override object Interpret(SucoEnvironment env, int?[] grid) => Left.Type.InterpretBinaryOperator(Left.Interpret(env, grid), Operator, Right.Type, Right.Interpret(env, grid));
public override object Interpret(SucoEnvironment env, int?[] grid) => env.GetPosition(Name);
public override object Interpret(SucoEnvironment env, int?[] grid) => LiteralValue;
public override object Interpret(SucoEnvironment env, int?[] grid) => Operand.Type.InterpretUnaryOperator(Operator, Operand.Interpret(env, grid));
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens) => new SucoConstant(StartIndex, EndIndex, Type, env.GetPosition(Name));
public override object Interpret(SucoEnvironment env, int?[] grid) => Operand.Type.InterpretMemberAccess(MemberName, Operand.Interpret(env, grid), env, grid);
public abstract bool?Interpret(SucoEnvironment env, int?[] grid);
public abstract object Optimize(SucoEnvironment env, int?[] givens);
public override SucoExpression Optimize(SucoEnvironment env, int?[] givens) => this;
public override object Interpret(SucoEnvironment env, int?[] grid) => Expression.Type.InterpretImplicitConversionTo(Type, Expression.Interpret(env, grid));
