public static Field Any(Runner runner, Node block)
{
if (block.Count != 2)
{
throw new ArgumentException();
}
return(runner.Eval(block[0]).Contains(runner.Eval(block[1])));
}
public static Field ShiftRight(Runner runner, Node block)
{
if (block.Count != 2)
{
throw new ArgumentException();
}
var a = runner.Eval(block[0]).IntValue;
var b = (int)runner.Eval(block[1]);
return((a >> b) & RunnerHelper.MAX_SAFE_INTEGER);
}
public static Field Atan(Runner runner, Node block)
{
if (block.Count < 1 || block.Count > 2)
{
throw new ArgumentException();
}
var a = runner.Eval(block[0]).FloatValue;
if (block.Count == 2)
{
var b = runner.Eval(block[1]).FloatValue;
return(Math.Atan2(a, b));
}
return(Math.Atan(a));
}
public static Field ToChar(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
var str = runner.Eval(block[0]);
var start = (int)runner.Eval(block[1]);
if (start < 0)
{
start = str.Count + start;
}
return((long)str[start]);
}
public Field Invoke(Runner runner, Node node)
{
try {
runner.PushContext();
for (int i = 0, l = Math.Min(arguments.Count, node.Count); i < l; i++)
{
runner.SetField(
runner.Eval(arguments[i]).StringValue,
runner.Eval(node[i]));
}
return(runner.Eval(body));
} finally {
runner.PopContext();
}
}
public static Field Return(Runner runner, Node block)
{
if (block.Count > 1)
{
throw new ArgumentException();
}
return(block.Count == 1 ? runner.Eval(block[0]) : default);
public static Field TypeOf(Runner runner, Node block)
{
if (block.Count != 1)
{
throw new ArgumentException();
}
switch (runner.Eval(block[1]).FieldType)
{
case FieldType.Unassigned: return("undefined");
case FieldType.Integer: return("integer");
case FieldType.Float: return("float");
case FieldType.String: return("string");
case FieldType.Object: return("object");
case FieldType.Array: return("array");
case FieldType.Function:
case FieldType.BuiltInFunction: return("function");
default: return("unknown");
}
}
public Field Invoke(Runner runner, Node node)
{
switch (fieldType)
{
case FieldType.BuiltInFunction:
case FieldType.Function:
return((objValue as IFunction).Invoke(runner, node));
case FieldType.Array:
case FieldType.Object:
var value = this;
for (int i = 1, l = node.Count; i < l; i++)
{
value = value.GetAndEnsureType(
runner.Eval(node[i]),
i < l - 1 ? FieldType.Object : FieldType.Unassigned);
}
return(value);
default:
if (node.Count > 0)
{
throw new InvalidCastException();
}
return(this);
}
}
public static Field Substract(Runner runner, Node block)
{
if (block.Count < 1)
{
throw new ArgumentException();
}
double?result = null;
foreach (var child in block)
{
var v = runner.Eval(child).FloatValue;
if (result.HasValue)
{
result += v;
}
else
{
result = -v;
}
}
if (block.Count > 1)
{
result = -result;
}
return(result.GetValueOrDefault(double.NaN));
}
public static Field Not(Runner runner, Node block)
{
if (block.Count != 1)
{
throw new ArgumentException();
}
var a = runner.Eval(block[0]).IntValue;
return((~a) & RunnerHelper.MAX_SAFE_INTEGER);
}
public static Field CreateArray(Runner runner, Node block)
{
Field result = new Field(FieldType.Array, block.Count);
foreach (var child in block)
{
result.Add(runner.Eval(child));
}
return(result);
}
public static Field Tanh(Runner runner, Node block)
{
if (block.Count != 1)
{
throw new ArgumentException();
}
var a = runner.Eval(block[0]).FloatValue;
return(Math.Tanh(a));
}
public static Field Slice(Runner runner, Node block)
{
if (block.Count < 2 || block.Count > 3)
{
throw new ArgumentException();
}
var src = runner.Eval(block[0]);
var start = (int)runner.Eval(block[1]);
var end = block.Count == 2 ? (int)runner.Eval(block[2]) : 0;
if (src.FieldType == FieldType.Array)
{
if (start < 0)
{
start = src.Count + start;
}
if (end <= 0)
{
end = src.Count + end;
}
Field result = new Field(FieldType.Array);
result.Capacity = end - start;
for (int i = start; i < end; i++)
{
result.Add(src[i]);
}
return(result);
}
else
{
var str = src.StringValue;
if (start < 0)
{
start = str.Length + start;
}
if (end <= 0)
{
end = str.Length + end;
}
return(str.Substring(start, end - start));
}
}
public static Field Delete(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
var target = runner.Eval(block[0]);
switch (target.FieldType)
{
case FieldType.Array:
switch (block.Count)
{
case 3:
target.RemoveRange(
(int)runner.Eval(block[1]),
(int)runner.Eval(block[2])
);
break;
case 2:
target.RemoveAt((int)runner.Eval(block[1]));
break;
default:
throw new ArgumentException();
}
break;
case FieldType.Object:
for (int i = 1, l = block.Count; i < l; i++)
{
target.Remove(runner.Eval(block[i]));
}
break;
default:
throw new ArgumentException();
}
return(target);
}
public static Field SetValue(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
var tag = Convert.ToString(block[0]);
if (block.Count == 2)
{
return(runner.SetField(tag, runner.Eval(block[1])));
}
Field field = runner.GetFieldOrInit(tag, FieldType.Object);
for (int i = 1, l = block.Count - 2; i < l; i++)
{
field = field.GetAndEnsureType(runner.Eval(block[i]), FieldType.Object);
}
return(field[runner.Eval(block[block.Count - 2])] =
runner.Eval(block[block.Count - 1]));
}
public static Field FromChar(Runner runner, Node block)
{
if (block.Count < 1)
{
throw new ArgumentException();
}
var result = new char[block.Count];
for (int i = 0, l = block.Count; i < l; i++)
{
result[i] = (char)runner.Eval(block[0]);
}
return(new string(result));
}
public static Field ToCharArray(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
var str = runner.Eval(block[0]).StringValue;
Field result = new Field(FieldType.Array, str.Length);
foreach (char c in str)
{
result.Add(c);
}
return(result);
}
public static Field Max(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
double result = double.NegativeInfinity;
foreach (var child in block)
{
var v = runner.Eval(child).FloatValue;
result = Math.Max(result, v);
}
return(result);
}
public static Field GetValue(Runner runner, Node block)
{
if (block.Count < 1)
{
throw new ArgumentException();
}
var tag = Convert.ToString(block[0]);
Field field = runner.GetFieldOrInit(tag,
block.Count > 2 ? FieldType.Object : FieldType.Unassigned);
for (int i = 1, l = block.Count; i < l; i++)
{
field = field.GetAndEnsureType(
runner.Eval(block[i]),
i < l - 1 ? FieldType.Object : FieldType.Unassigned);
}
return(field);
}
public static Field GreaterThenEquals(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
double compareNum = double.PositiveInfinity;
foreach (var child in block)
{
var v = runner.Eval(child).FloatValue;
if (compareNum < v)
{
return(0);
}
compareNum = v;
}
return(1);
}
public static Field OrElse(Runner runner, Node block)
{
if (block.Count < 1)
{
throw new ArgumentException();
}
Field result = default;
foreach (var child in block)
{
var nextResult = runner.Eval(child);
if (nextResult.IsTruly)
{
return(nextResult);
}
result = nextResult;
}
return(result);
}
public static Field RunSequence(Runner runner, Node block)
{
if (block.Count < 1)
{
throw new ArgumentException();
}
Field result = default;
foreach (var child in block)
{
result = runner.Eval(child);
var field = runner.GetFieldOrInit(Convert.ToString(child));
if (field.FieldType == FieldType.BuiltInFunction &&
field.Value == index["return"])
{
return(result);
}
}
return(result);
}
public static Field Length(Runner runner, Node block)
{
if (block.Count != 1)
{
throw new ArgumentException();
}
var obj = runner.Eval(block[1]);
switch (obj.FieldType)
{
case FieldType.String:
return(obj.StringValue.Length);
case FieldType.Array:
case FieldType.Object:
return(obj.Count);
default:
return(0);
}
}
public static Field Pow(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
double?result = null;
foreach (var child in block)
{
var v = runner.Eval(child).FloatValue;
if (result.HasValue)
{
result = Math.Pow(result.Value, v);
}
else
{
result = v;
}
}
return(result.GetValueOrDefault(double.NaN));
}
public static Field Xor(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
long?result = null;
foreach (var child in block)
{
var v = runner.Eval(child).IntValue;
if (result.HasValue)
{
result ^= v;
}
else
{
result = v;
}
}
return(result.GetValueOrDefault(0));
}
public static Field Equals(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
var compareFieldType = FieldType.Unassigned;
string compareStr = null;
double compareNum = double.NaN;
object compareObj = null;
foreach (var child in block)
{
var v = runner.Eval(child);
switch (compareFieldType)
{
case FieldType.Unassigned:
switch (v.FieldType)
{
case FieldType.String:
compareFieldType = FieldType.String;
compareStr = v.StringValue;
break;
case FieldType.Integer:
case FieldType.Float:
compareFieldType = FieldType.Float;
compareNum = v.FloatValue;
break;
}
compareFieldType = FieldType.Object;
compareObj = v;
break;
case FieldType.String:
if (v.StringValue != compareStr)
{
return(0);
}
break;
case FieldType.Float:
if (v.FloatValue != compareNum)
{
return(0);
}
break;
case FieldType.Object:
if (v.Value != compareObj)
{
return(0);
}
break;
default:
throw new ArgumentException();
}
}
switch (compareFieldType)
{
case FieldType.Float:
case FieldType.String:
case FieldType.Object:
return(1);
default:
throw new ArgumentException();
}
}
public static Field Add(Runner runner, Node block)
{
if (block.Count < 2)
{
throw new ArgumentException();
}
var fieldType = FieldType.Unassigned;
StringBuilder resultStr = null;
double? resultNum = null;
Field resultList = default;
foreach (var child in block)
{
var v = runner.Eval(child);
switch (fieldType)
{
case FieldType.Unassigned:
switch (v.FieldType)
{
case FieldType.String:
fieldType = FieldType.String;
resultStr = new StringBuilder((string)v);
break;
case FieldType.Integer:
case FieldType.Float:
fieldType = FieldType.Float;
resultNum = v.FloatValue;
break;
case FieldType.Array:
fieldType = FieldType.Array;
resultList = v;
break;
default:
throw new ArgumentException();
}
break;
case FieldType.Array:
if (v.FieldType == FieldType.Array)
{
foreach (var entry in v)
{
resultList.Add(entry);
}
}
else
{
resultList.Add(v);
}
break;
case FieldType.String:
resultStr.Append(v);
break;
case FieldType.Float:
resultNum += v.FloatValue;
break;
default:
throw new ArgumentException();
}
}
switch (fieldType)
{
case FieldType.Float:
return(resultNum.GetValueOrDefault(double.NaN));
case FieldType.String:
return(resultStr.ToString());
case FieldType.Array:
return(resultList);
default:
throw new ArgumentException();
}
}
