public DekiScriptExpression Visit(DekiScriptBinary expr, DekiScriptExpressionEvaluationState state)
{
DekiScriptExpression left = expr.Left.VisitWith(this, state);
DekiScriptExpression right = expr.Right.VisitWith(this, state);
DekiScriptExpression result = DekiScriptExpression.BinaryOp(expr.Location, expr.OpCode, left, right);
if ((left is DekiScriptLiteral) && (right is DekiScriptLiteral))
{
result = state.Pop(result.VisitWith(DekiScriptExpressionEvaluation.Instance, state));
}
return(result);
}
public DekiScriptExpression Visit(DekiScriptBinary expr, DekiScriptOptimizerState state)
{
DekiScriptExpression left = expr.Left.VisitWith(this, state);
DekiScriptExpression right = expr.Right.VisitWith(this, state);
DekiScriptExpression result = new DekiScriptBinary(expr.Line, expr.Column, expr.OpCode, left, right);
if ((left is DekiScriptLiteral) && (right is DekiScriptLiteral))
{
result = result.Evaluate(state.Env);
}
return(result);
}
public DekiScriptLiteral Visit(DekiScriptSwitch expr, DekiScriptEnv env)
{
DekiScriptLiteral value = expr.Value.VisitWith(this, env);
DekiScriptCaseBlock defaultCase = null;
// have to use for instead of foreach, since a fallthrough default case needs to be able to look ahead
for (int i = 0; i < expr.Cases.Length; i++)
{
DekiScriptCaseBlock c = expr.Cases[i];
// check for default case
DekiScriptEnv locals = env.NewLocalScope();
foreach (DekiScriptExpression condition in c.Conditions)
{
if (condition == null)
{
// check if this is the first default we've found
if (defaultCase == null)
{
defaultCase = c;
}
// continue in case loop, since default only gets executed if there is no match
continue;
}
// evaluate test
DekiScriptBinary test = new DekiScriptBinary(0, 0, DekiScriptBinary.Op.Equal, value, condition);
DekiScriptLiteral caseMatch = test.VisitWith(this, locals);
// evaluate body on success
if (!caseMatch.IsNilFalseZero)
{
return(EvalBody(locals, c.Body));
}
}
}
// haven't found a match yet, so if we have a default, return it
if (defaultCase != null)
{
return(EvalBody(env.NewLocalScope(), defaultCase.Body));
}
return(DekiScriptNil.Value);
}
private object Optimize(DekiScriptCaseBlock expr, DekiScriptExpression value, DekiScriptEvalMode mode, DekiScriptEnv env, out bool isDefaultCase)
{
List <DekiScriptExpression> conditions = new List <DekiScriptExpression>();
isDefaultCase = false;
for (int i = 0; i < expr.Conditions.Length; i++)
{
if (expr.Conditions[i] != null)
{
DekiScriptExpression condition = expr.Conditions[i].VisitWith(this, new DekiScriptOptimizerState(mode, env));
// check if condition always succeeds or always fails
if ((value is DekiScriptLiteral) && (condition is DekiScriptLiteral))
{
DekiScriptBinary test = new DekiScriptBinary(0, 0, DekiScriptBinary.Op.Equal, value, condition);
if (!test.Evaluate(env).IsNilFalseZero)
{
// NOTE (steveb): we wrap the outcome into a sequence to ensure proper handling of break/continue statements
// condition succeeded, return it
return(DekiScriptSequence.New(DekiScriptSequence.ScopeKind.ScopeCatchBreakAndContinue, expr.Body.VisitWith(this, new DekiScriptOptimizerState(mode, env))));
}
}
else
{
conditions.Add(condition);
}
}
else
{
isDefaultCase = true;
conditions.Add(null);
}
}
// check if any conditions were true or unknown
if (conditions.Count == 0)
{
return(null);
}
DekiScriptExpression body = expr.Body.VisitWith(this, new DekiScriptOptimizerState(mode, env));
return(new DekiScriptCaseBlock(conditions.ToArray(), body, expr.IsBlock));
}
public DekiScriptOutputBuffer.Range Visit(DekiScriptBinary expr, DekiScriptExpressionEvaluationState state)
{
DekiScriptExpression Left = expr.Left;
DekiScriptExpression Right = expr.Right;
switch (expr.OpCode)
{
case DekiScriptBinary.Op.LeftValue:
return(Left.VisitWith(this, state));
case DekiScriptBinary.Op.IdentityEqual: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
return(state.Push(DekiScriptBinary.IdentityEqual(left, right)));
}
case DekiScriptBinary.Op.IdentityNotEqual: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
return(state.Push(DekiScriptBinary.IdentityNotEqual(left, right)));
}
case DekiScriptBinary.Op.IsType: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
string type = ((DekiScriptString)Right).Value;
return(state.Push(DekiScriptExpression.Constant(type.EqualsInvariantIgnoreCase("any") || left.ScriptTypeName.EqualsInvariantIgnoreCase(type))));
}
case DekiScriptBinary.Op.Equal: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
return(state.Push(DekiScriptBinary.Equal(left, right)));
}
case DekiScriptBinary.Op.NotEqual: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
return(state.Push(DekiScriptBinary.NotEqual(left, right)));
}
case DekiScriptBinary.Op.GreaterOrEqual: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (DekiScriptLiteral.CoerceValuesToSameType(ref left, ref right))
{
switch (left.ScriptType)
{
case DekiScriptType.BOOL:
case DekiScriptType.NUM:
return(state.Push(DekiScriptExpression.Constant(left.AsNumber() >= right.AsNumber())));
case DekiScriptType.STR:
return(state.Push(DekiScriptExpression.Constant(left.AsString().CompareInvariant(right.AsString()) >= 0)));
default:
return(DekiScriptOutputBuffer.Range.Empty);
}
}
else
{
return(DekiScriptOutputBuffer.Range.Empty);
}
}
case DekiScriptBinary.Op.GreaterThan: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (DekiScriptLiteral.CoerceValuesToSameType(ref left, ref right))
{
switch (left.ScriptType)
{
case DekiScriptType.BOOL:
case DekiScriptType.NUM:
return(state.Push(DekiScriptExpression.Constant(left.AsNumber() > right.AsNumber())));
case DekiScriptType.STR:
return(state.Push(DekiScriptExpression.Constant(left.AsString().CompareInvariant(right.AsString()) > 0)));
default:
return(DekiScriptOutputBuffer.Range.Empty);
}
}
else
{
return(DekiScriptOutputBuffer.Range.Empty);
}
}
case DekiScriptBinary.Op.LessOrEqual: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (DekiScriptLiteral.CoerceValuesToSameType(ref left, ref right))
{
switch (left.ScriptType)
{
case DekiScriptType.BOOL:
case DekiScriptType.NUM:
return(state.Push(DekiScriptExpression.Constant(left.AsNumber() <= right.AsNumber())));
case DekiScriptType.STR:
return(state.Push(DekiScriptExpression.Constant(left.AsString().CompareInvariant(right.AsString()) <= 0)));
default:
return(DekiScriptOutputBuffer.Range.Empty);
}
}
else
{
return(DekiScriptOutputBuffer.Range.Empty);
}
}
case DekiScriptBinary.Op.LessThan: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (DekiScriptLiteral.CoerceValuesToSameType(ref left, ref right))
{
switch (left.ScriptType)
{
case DekiScriptType.BOOL:
case DekiScriptType.NUM:
return(state.Push(DekiScriptExpression.Constant(left.AsNumber() < right.AsNumber())));
case DekiScriptType.STR:
return(state.Push(DekiScriptExpression.Constant(left.AsString().CompareInvariant(right.AsString()) < 0)));
default:
return(DekiScriptOutputBuffer.Range.Empty);
}
}
else
{
return(DekiScriptOutputBuffer.Range.Empty);
}
}
case DekiScriptBinary.Op.LogicalAnd: {
DekiScriptLiteral result = state.Pop(Left.VisitWith(this, state));
if (!result.IsNilFalseZero)
{
return(Right.VisitWith(this, state));
}
return(state.Push(result));
}
case DekiScriptBinary.Op.LogicalOr: {
DekiScriptLiteral result = state.Pop(Left.VisitWith(this, state));
if (result.IsNilFalseZero)
{
return(Right.VisitWith(this, state));
}
return(state.Push(result));
}
case DekiScriptBinary.Op.Addition:
return(state.Push(DekiScriptExpression.Constant(state.Pop(Left.VisitWith(this, state)).AsNumber() + state.Pop(Right.VisitWith(this, state)).AsNumber())));
case DekiScriptBinary.Op.Division:
return(state.Push(DekiScriptExpression.Constant(state.Pop(Left.VisitWith(this, state)).AsNumber() / state.Pop(Right.VisitWith(this, state)).AsNumber())));
case DekiScriptBinary.Op.Modulo: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if ((left is DekiScriptString) && ((right is DekiScriptMap) || (right is DekiScriptList)))
{
// NOTE (steveb): string.format shorthand notation: "abc = $abc" % { abc: 123 } -OR- "0 = $0" % [ 123 ]
return(state.Push(DekiScriptLiteral.FromNativeValue(DekiScriptLibrary.StringFormat(((DekiScriptString)left).Value, right.NativeValue))));
}
else
{
return(state.Push(DekiScriptExpression.Constant(left.AsNumber() % right.AsNumber())));
}
}
case DekiScriptBinary.Op.Multiplication:
return(state.Push(DekiScriptExpression.Constant(state.Pop(Left.VisitWith(this, state)).AsNumber() * state.Pop(Right.VisitWith(this, state)).AsNumber())));
case DekiScriptBinary.Op.Subtraction:
return(state.Push(DekiScriptExpression.Constant(state.Pop(Left.VisitWith(this, state)).AsNumber() - state.Pop(Right.VisitWith(this, state)).AsNumber())));
case DekiScriptBinary.Op.NullCoalesce: {
DekiScriptLiteral result = state.Pop(Left.VisitWith(this, state));
if (result.IsNil)
{
return(Right.VisitWith(this, state));
}
return(state.Push(result));
}
case DekiScriptBinary.Op.Concat: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (left is DekiScriptNil)
{
return(state.Push(right));
}
else if (right is DekiScriptNil)
{
return(state.Push(left));
}
else if ((left is DekiScriptMap) && (right is DekiScriptMap))
{
// left and right expressions are maps, merge them
DekiScriptMap result = new DekiScriptMap();
result.AddRange((DekiScriptMap)left);
result.AddRange((DekiScriptMap)right);
return(state.Push(result));
}
else if ((left is DekiScriptList) && (right is DekiScriptList))
{
// left and right expressions are lists, concatenate them
DekiScriptList result = new DekiScriptList();
result.AddRange((DekiScriptList)left);
result.AddRange((DekiScriptList)right);
return(state.Push(result));
}
else
{
// treat left and right expressions as strings
string leftText = left.AsString();
string rightText = right.AsString();
if ((leftText != null) && (rightText != null))
{
return(state.Push(DekiScriptExpression.Constant(leftText + rightText)));
}
else if (leftText != null)
{
return(state.Push(DekiScriptExpression.Constant(leftText)));
}
else if (rightText != null)
{
return(state.Push(DekiScriptExpression.Constant(rightText)));
}
else
{
return(DekiScriptOutputBuffer.Range.Empty);
}
}
}
case DekiScriptBinary.Op.UriAppend: {
// TODO (steveb): we should throw an exception when the LHS is not a valid string or uri
XUri left = XUri.TryParse(state.Pop(Left.VisitWith(this, state)).AsString());
string result = null;
if (left != null)
{
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (right is DekiScriptString)
{
result = DekiScriptLibrary.UriBuild(left, right.AsString(), null);
}
else if (right is DekiScriptMap)
{
result = DekiScriptLibrary.UriBuild(left, null, (Hashtable)right.NativeValue);
}
else
{
result = left.ToString();
}
}
return(state.Push(DekiScriptLiteral.FromNativeValue(result)));
}
case DekiScriptBinary.Op.InCollection: {
DekiScriptLiteral left = state.Pop(Left.VisitWith(this, state));
DekiScriptLiteral right = state.Pop(Right.VisitWith(this, state));
if (right is DekiScriptList)
{
foreach (DekiScriptLiteral item in ((DekiScriptList)right).Value)
{
if (!DekiScriptBinary.Equal(left, item).IsNilFalseZero)
{
return(state.Push(DekiScriptBool.True));
}
}
return(state.Push(DekiScriptBool.False));
}
else if (right is DekiScriptMap)
{
foreach (DekiScriptLiteral item in ((DekiScriptMap)right).Value.Values)
{
if (!DekiScriptBinary.Equal(left, item).IsNilFalseZero)
{
return(state.Push(DekiScriptBool.True));
}
}
return(state.Push(DekiScriptBool.False));
}
else
{
return(state.Push(DekiScriptBool.False));
}
}
}
throw new InvalidOperationException("invalid op code:" + expr.OpCode);
}
