private static ScriptingValue PrimitiveXor(ScriptingValue[] arguments)
{
bool a = (bool)arguments[0].Value;
bool b = (bool)arguments[1].Value;
return(ScriptingValue.CreateValue(a ^ b));
}
// split pattern string
private static ScriptingValue Split(ScriptingValue[] arguments)
{
string p = (string)arguments[0].Value;
string s = (string)arguments[1].Value;
return(ScriptingValue.CreateValue(s.Split(new string[] { p }, StringSplitOptions.None).Cast <object>().ToArray()));
}
// find pattern string
private static ScriptingValue Find(ScriptingValue[] arguments)
{
string p = (string)arguments[0].Value;
string s = (string)arguments[1].Value;
return(ScriptingValue.CreateValue(s.IndexOf(p, StringComparison.CurrentCulture)));
}
private static CompareResult Compare(ScriptingValue a, ScriptingValue b)
{
if (a.IsInvokable || b.IsInvokable)
{
return(CompareResult.NotComparable);
}
else if (a.IsArray && b.IsArray)
{
return(a.SequenceEqual(b, new ScriptingValueComparer()) ? CompareResult.EqualTo : CompareResult.NotComparable);
}
else
{
try
{
object obja = a.Value;
object objb = b.Value;
if (obja is int)
{
if (objb is int)
{
return(ConvertCompareResult(((int)obja).CompareTo((int)objb)));
}
else if (objb is double)
{
return(ConvertCompareResult(((double)(int)obja).CompareTo((double)objb)));
}
}
else if (obja is double)
{
if (objb is int)
{
return(ConvertCompareResult(((double)obja).CompareTo((double)(int)objb)));
}
else if (objb is double)
{
return(ConvertCompareResult(((double)obja).CompareTo((double)objb)));
}
}
else if (obja is string)
{
if (objb is string)
{
return(ConvertCompareResult(((string)obja).CompareTo((string)objb)));
}
}
else if (obja is bool)
{
if (objb is bool)
{
return(ConvertCompareResult(((bool)obja).CompareTo((bool)objb)));
}
}
return(ConvertCompareResult(((IComparable)obja).CompareTo(objb)));
}
catch (Exception)
{
return(CompareResult.NotComparable);
}
}
}
// empty string/array
private static ScriptingValue Empty(ScriptingValue[] arguments)
{
if (arguments[0].IsArray)
{
return(ScriptingValue.CreateValue(arguments[0].Length == 0));
}
else
{
return(ScriptingValue.CreateValue(((string)arguments[0].Value).Length == 0));
}
}
// item index string/array
private static ScriptingValue Item(ScriptingValue[] arguments)
{
int index = (int)arguments[0].Value;
if (arguments[1].IsArray)
{
return(ScriptingValue.CreateValue(arguments[1][index]));
}
else
{
return(ScriptingValue.CreateValue(((string)arguments[1].Value)[index].ToString()));
}
}
private static ScriptingValue PrimitiveNeg(ScriptingValue[] arguments)
{
IConvertible a = (IConvertible)arguments[0].Value;
if (a is int)
{
return(ScriptingValue.CreateValue(-a.ToInt32(CultureInfo.InvariantCulture)));
}
else
{
return(ScriptingValue.CreateValue(-a.ToDouble(CultureInfo.InvariantCulture)));
}
}
private static ScriptingValue PrimitiveConcat(ScriptingValue[] arguments)
{
object a = arguments[0].Value;
object b = arguments[1].Value;
if (a is string && b is string)
{
return(ScriptingValue.CreateValue(((IConvertible)a).ToString(CultureInfo.InvariantCulture) + ((IConvertible)b).ToString(CultureInfo.InvariantCulture)));
}
else
{
return(ScriptingValue.CreateArray(arguments[0].Concat(arguments[1]).ToArray()));
}
}
private static ScriptingValue PrimitiveMod(ScriptingValue[] arguments)
{
IConvertible a = (IConvertible)arguments[0].Value;
IConvertible b = (IConvertible)arguments[1].Value;
if (a is int && b is int)
{
return(ScriptingValue.CreateValue(a.ToInt32(CultureInfo.InvariantCulture) % b.ToInt32(CultureInfo.InvariantCulture)));
}
else
{
return(ScriptingValue.CreateValue(Math.IEEERemainder(a.ToDouble(CultureInfo.InvariantCulture), b.ToDouble(CultureInfo.InvariantCulture))));
}
}
// reg_find pattern string
private static ScriptingValue RegFind(ScriptingValue[] arguments)
{
string p = (string)arguments[0].Value;
string s = (string)arguments[1].Value;
Match match = new Regex(p).Match(s);
if (match.Success)
{
return(ScriptingValue.CreateArray(match.Index, match.Value));
}
else
{
return(ScriptingValue.CreateArray(-1, ""));
}
}
// read_file file_name
private static ScriptingValue ReadFile(ScriptingValue[] arguments)
{
string filename = (string)arguments[0].Value;
try
{
using (StreamReader reader = new StreamReader(filename, true))
{
return(ScriptingValue.CreateValue(reader.ReadToEnd()));
}
}
catch (Exception)
{
return(ScriptingValue.CreateArray(new object[] { }));
}
}
// write_file file_name content
private static ScriptingValue WriteFile(ScriptingValue[] arguments)
{
string filename = (string)arguments[0].Value;
string content = (string)arguments[0].Value;
try
{
using (StreamWriter writer = new StreamWriter(filename))
{
writer.Write(content);
}
return(ScriptingValue.CreateValue(true));
}
catch (Exception)
{
return(ScriptingValue.CreateValue(false));
}
}
// reg_find_all pattern string
private static ScriptingValue RegFindAll(ScriptingValue[] arguments)
{
Regex p = new Regex((string)arguments[0].Value);
string s = (string)arguments[1].Value;
int index = 0;
List <object[]> result = new List <object[]>();
while (index < s.Length)
{
Match match = p.Match(s, index);
if (match.Success)
{
result.Add(new object[] { match.Index, match.Value });
index = match.Index + match.Length;
}
else
{
break;
}
}
return(ScriptingValue.CreateArray(result.Cast <object>().ToArray()));
}
// find_all pattern string
private static ScriptingValue FindAll(ScriptingValue[] arguments)
{
string p = (string)arguments[0].Value;
string s = (string)arguments[1].Value;
int index = 0;
List <int> result = new List <int>();
while (index < s.Length)
{
int pos = s.IndexOf(p, index, StringComparison.CurrentCulture);
if (pos == -1)
{
break;
}
else
{
result.Add(pos);
index = pos + p.Length;
}
}
return(ScriptingValue.CreateArray(result.Cast <object>().ToArray()));
}
private static ScriptingValue ToString(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateValue(((IConvertible)arguments[0].Value).ToString(CultureInfo.CurrentCulture)));
}
private static ScriptingValue PrimitiveGt(ScriptingValue[] arguments)
{
CompareResult result = Compare(arguments[0], arguments[1]);
return(ScriptingValue.CreateValue(result == CompareResult.GreaterThan));
}
private static ScriptingValue PrimitiveNe(ScriptingValue[] arguments)
{
CompareResult result = Compare(arguments[0], arguments[1]);
return(ScriptingValue.CreateValue(result != CompareResult.EqualTo));
}
private static ScriptingValue DoubleFunction(MethodInfo method, ScriptingValue[] argument)
{
return(ScriptingValue.CreateValue((double)method.Invoke(null, argument.Select(v => (object)((IConvertible)v.Value).ToDouble(CultureInfo.InvariantCulture)).ToArray())));
}
public static void LoadLibrary(ScriptingEnvironment e)
{
e.DefineValue("pure", ScriptingValue.CreateValue(new PureMonad()));
e.DefineValue("ordered", ScriptingValue.CreateValue(new OrderedMonad()));
e.DefineValue("state", ScriptingValue.CreateFunction(State, 1));
e.DefineValue("continue", ScriptingValue.CreateFunction(Continue, 1));
e.DefineValue("io", ScriptingValue.CreateFunction(IOContinue, 1));
e.DefineValue("create_state", new ScriptingValue(RuntimeValueWrapper.CreateFunction(StateMonad.ReturnStateMonadValue, 2)));
e.DefineValue("(+)", ScriptingValue.CreateFunction(PrimitiveAdd, 2));
e.DefineValue("(-)", ScriptingValue.CreateFunction(PrimitiveSub, 2));
e.DefineValue("(*)", ScriptingValue.CreateFunction(PrimitiveMul, 2));
e.DefineValue("(/)", ScriptingValue.CreateFunction(PrimitiveDiv, 2));
e.DefineValue("(%)", ScriptingValue.CreateFunction(PrimitiveMod, 2));
e.DefineValue("(++)", ScriptingValue.CreateFunction(PrimitiveConcat, 2));
e.DefineValue("(<)", ScriptingValue.CreateFunction(PrimitiveLt, 2));
e.DefineValue("(<=)", ScriptingValue.CreateFunction(PrimitiveLe, 2));
e.DefineValue("(>)", ScriptingValue.CreateFunction(PrimitiveGt, 2));
e.DefineValue("(>=)", ScriptingValue.CreateFunction(PrimitiveGe, 2));
e.DefineValue("(==)", ScriptingValue.CreateFunction(PrimitiveEq, 2));
e.DefineValue("(!=)", ScriptingValue.CreateFunction(PrimitiveNe, 2));
e.DefineValue("(&&)", ScriptingValue.CreateFunction(PrimitiveAnd, 2));
e.DefineValue("(||)", ScriptingValue.CreateFunction(PrimitiveOr, 2));
e.DefineValue("(^)", ScriptingValue.CreateFunction(PrimitiveXor, 2));
e.DefineValue("not", ScriptingValue.CreateFunction(PrimitiveNot, 1));
e.DefineValue("neg", ScriptingValue.CreateFunction(PrimitiveNeg, 1));
e.DefineValue("unit", ScriptingValue.CreateFunction(PrimitiveUnit, 1));
foreach (MethodInfo method in typeof(Math).GetMethods(BindingFlags.Public | BindingFlags.Static))
{
if (method.ReturnType == typeof(double) && method.GetParameters().Length > 0 && method.GetParameters().All(p => p.ParameterType == typeof(double)))
{
string methodName = method.Name.ToLower();
if (!e.IsDefined(methodName))
{
e.DefineValue(methodName, ScriptingValue.CreateFunction(MakeDoubleFunction(method), method.GetParameters().Length));
}
}
}
e.DefineValue("pi", ScriptingValue.CreateValue(Math.PI));
e.DefineValue("e", ScriptingValue.CreateValue(Math.E));
e.DefineValue("aggregate", ScriptingValue.CreateFunction(Aggregate, 3));
e.DefineValue("distinct", ScriptingValue.CreateFunction(Distinct, 1));
e.DefineValue("except", ScriptingValue.CreateFunction(Except, 2));
e.DefineValue("first", ScriptingValue.CreateFunction(First, 2));
e.DefineValue("intersect", ScriptingValue.CreateFunction(Intersect, 2));
e.DefineValue("last", ScriptingValue.CreateFunction(Last, 2));
e.DefineValue("order_by", ScriptingValue.CreateFunction(OrderBy, 2));
e.DefineValue("reverse", ScriptingValue.CreateFunction(Reverse, 1));
e.DefineValue("select", ScriptingValue.CreateFunction(Select, 2));
e.DefineValue("select_many", ScriptingValue.CreateFunction(SelectMany, 2));
e.DefineValue("skip", ScriptingValue.CreateFunction(Skip, 2));
e.DefineValue("skip_while", ScriptingValue.CreateFunction(SkipWhile, 2));
e.DefineValue("take", ScriptingValue.CreateFunction(Take, 2));
e.DefineValue("take_while", ScriptingValue.CreateFunction(TakeWhile, 2));
e.DefineValue("union", ScriptingValue.CreateFunction(Union, 2));
e.DefineValue("where", ScriptingValue.CreateFunction(Where, 2));
e.DefineValue("zip", ScriptingValue.CreateFunction(Zip, 2));
e.DefineValue("to_lower", ScriptingValue.CreateFunction(ToLower, 1));
e.DefineValue("to_upper", ScriptingValue.CreateFunction(ToUpper, 1));
e.DefineValue("find", ScriptingValue.CreateFunction(Find, 2));
e.DefineValue("find_all", ScriptingValue.CreateFunction(FindAll, 2));
e.DefineValue("reg_find", ScriptingValue.CreateFunction(RegFind, 2));
e.DefineValue("reg_find_all", ScriptingValue.CreateFunction(RegFindAll, 2));
e.DefineValue("length", ScriptingValue.CreateFunction(Length, 1));
e.DefineValue("item", ScriptingValue.CreateFunction(Item, 2));
e.DefineValue("empty", ScriptingValue.CreateFunction(Empty, 1));
e.DefineValue("split", ScriptingValue.CreateFunction(Split, 2));
e.DefineValue("to_int", ScriptingValue.CreateFunction(ToInt, 1));
e.DefineValue("to_double", ScriptingValue.CreateFunction(ToDouble, 1));
e.DefineValue("to_string", ScriptingValue.CreateFunction(ToString, 1));
e.DefineValue("read_file", ScriptingValue.CreateFunction(ReadFile, 1));
e.DefineValue("write_file", ScriptingValue.CreateFunction(WriteFile, 2));
}
// select_many converter list
private static ScriptingValue SelectMany(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[1].SelectMany(v => arguments[0].Invoke(v)).ToArray()));
}
// order_by converter list
private static ScriptingValue OrderBy(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[1].OrderBy(s => arguments[0].Invoke(s), new ScriptingValueComparer()).ToArray()));
}
// zip list2 list1
private static ScriptingValue Zip(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[1].Zip(arguments[0], (a, b) => ScriptingValue.CreateArray(a, b)).ToArray()));
}
// to_upper string
private static ScriptingValue ToUpper(ScriptingValue[] arguments)
{
string s = (string)arguments[0].Value;
return(ScriptingValue.CreateValue(s.ToUpper(CultureInfo.CurrentCulture)));
}
// where predicate list
private static ScriptingValue Where(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[1].Where(v => (bool)arguments[0].Invoke(v).Value).ToArray()));
}
private static ScriptingValue IOContinue(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateValue(arguments[0].Value is Exception));
}
// take number list
private static ScriptingValue Take(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[1].Take((int)arguments[0].Value).ToArray()));
}
private static ScriptingValue PrimitiveNot(ScriptingValue[] arguments)
{
bool a = (bool)arguments[0].Value;
return(ScriptingValue.CreateValue(!a));
}
// distinct list
private static ScriptingValue Distinct(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[0].Distinct(new ScriptingValueComparer()).ToArray()));
}
// union list2 list1
private static ScriptingValue Union(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[1].Union(arguments[0], new ScriptingValueComparer()).ToArray()));
}
// reverse list
private static ScriptingValue Reverse(ScriptingValue[] arguments)
{
return(ScriptingValue.CreateArray(arguments[0].Reverse().ToArray()));
}
