public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var m = args.GetMap("m");
m.GetValue()[args.Get("key")] = args.Get("value");
return(m);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var lst = args.Get("lst");
var element = args.Get("element");
try
{
if (lst.IsList())
{
lst.AsList().GetValue().Add(element);
return(lst);
}
if (lst.IsSet())
{
lst.AsSet().GetValue().Add(element);
return(lst);
}
}
catch
{
// handled below
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot append to " + lst, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
return(ValueBoolean.From(!a.IsEquals(b)));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var lst = args.Get("lst");
if (!lst.IsList())
{
throw new ControlErrorException(new ValueString("ERROR"), "Cannot insert into object of type " + lst.Type(), pos);
}
var index = (int)args.GetInt("index").GetValue();
if (index < 0)
{
index = lst.AsList().GetValue().Count + index + 1;
}
var value = args.Get("value");
var list = lst.AsList().GetValue();
if (index < 0 || index > list.Count)
{
return(lst);
}
if (index == list.Count)
{
list.Add(value);
}
else
{
list.Insert(index, value);
}
return(lst);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
if (a.IsNull() || b.IsNull())
{
return(ValueNull.NULL);
}
if (a.IsList() && b.IsList())
{
var lista = a.AsList().GetValue();
var listb = b.AsList().GetValue();
var result = new ValueMap();
for (var i = 0; i < Math.Min(lista.Count, listb.Count); i++)
{
result.AddItem(lista[i], listb[i]);
}
return(result);
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot zip_map " + a + " and " + b, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
return(ValueBoolean.From(a.CompareTo(b) < 0));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
return(new ValueInt(a.CompareTo(b)));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var result = new ValueList();
if (!args.HasArg("module"))
{
foreach (var symbol in environment.GetSymbols())
{
result.AddItem(new ValueString(symbol));
}
}
else
{
var moduleArg = args.Get("module");
Dictionary <string, Value> module;
if (moduleArg.IsString())
{
module = environment.Get(moduleArg.AsString().GetValue(), pos).AsObject().value;
}
else
{
module = args.Get("module").AsObject().value;
}
foreach (var symbol in module.Keys)
{
result.AddItem(new ValueString(symbol));
}
}
return(result);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var inparg = args.Get("input");
var callback = args.Get("callback").AsFunc();
Environment env = environment.NewEnv();
if (inparg is ValueInput)
{
ValueInput input = inparg.AsInput();
return(new ValueInt(input.Process(line => {
Args args_ = new Args(callback.GetArgNames()[0], new ValueString(line), pos);
return callback.Execute(args_, env, pos);
})));
}
if (inparg is ValueList)
{
var list = inparg.AsList().GetValue();
foreach (var element in list)
{
Args args_ = new Args(callback.GetArgNames()[0], element.AsString(), pos);
callback.Execute(args_, env, pos);
}
;
return(new ValueInt(list.Count));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot process lines from " + inparg, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
if (a.IsString() && a.AsString().GetValue().Length == 0)
{
return(args.Get("b"));
}
return(a);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
if (a.IsNull())
{
return(args.Get("b"));
}
return(a);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var arg = args.Get("obj");
if (arg.IsString())
{
return(new ValueInt(arg.AsString().GetValue().Length));
}
if (arg.IsList())
{
return(new ValueInt(arg.AsList().GetValue().Count));
}
if (arg.IsSet())
{
return(new ValueInt(arg.AsSet().GetValue().Count));
}
if (arg.IsMap())
{
return(new ValueInt(arg.AsMap().GetValue().Count));
}
if (arg.IsObject())
{
return(new ValueInt(arg.AsObject().value.Count));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot determine length of " + arg, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
if (a.IsNull() || b.IsNull())
{
return(ValueNull.NULL);
}
if (a.IsInt() && b.IsInt())
{
return(new ValueInt(a.AsInt().GetValue() * b.AsInt().GetValue()));
}
if (a.IsNumerical() && b.IsNumerical())
{
return(new ValueDecimal(a.AsDecimal().GetValue() * b.AsDecimal().GetValue()));
}
if (a.IsString() && b.IsInt())
{
var s = a.AsString().GetValue();
var r = "";
for (var i = 0; i < b.AsInt().GetValue(); i++)
{
r += s;
}
return(new ValueString(r));
}
if (a.IsList() && b.IsInt())
{
var result = new List <Value>();
for (var i = 0; i < b.AsInt().GetValue(); i++)
{
result.AddRange(a.AsList().GetValue());
}
return(new ValueList(result));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot multiply " + a + " by " + b, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
if (args.Get(("s")).IsNode())
{
return(args.GetAsNode("s").GetValue().Evaluate(environment));
}
var node = Parser.Parse(args.GetString("s").GetValue(), pos.filename);
return(node.Evaluate(environment));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
if (a.IsNull() || b.IsNull())
{
return(ValueNull.NULL);
}
Value div_0_value;
if (args.HasArg("div_0_value"))
{
div_0_value = args.Get("div_0_value");
}
else
{
div_0_value = new ValueInt(long.MaxValue);
}
if (a.IsInt() && b.IsInt())
{
var divisor = b.AsInt().GetValue();
if (divisor == 0)
{
return(div_0_value);
}
return(new ValueInt(a.AsInt().GetValue() / divisor));
}
if (a.IsNumerical() && b.IsNumerical())
{
var divisor = b.AsDecimal().GetValue();
if (divisor == 0)
{
return(div_0_value);
}
return(new ValueDecimal(a.AsDecimal().GetValue() / divisor));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot div0 " + a + " by " + b, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var f = args.Get("f");
if (f is FuncLambda)
{
return(new ValueNode(((FuncLambda)f).GetBody()));
}
throw new ControlErrorException(new ValueString("ERROR"), "f is not a lambda function", pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
if (a.IsNull() || b.IsNull())
{
return(ValueNull.NULL);
}
if (a.IsInt() && b.IsInt())
{
var divisor = b.AsInt().GetValue();
if (divisor == 0)
{
if (environment.IsDefined("DIV_0_VALUE") &&
environment.Get("DIV_0_VALUE", pos) != ValueNull.NULL)
{
return(environment.Get("DIV_0_VALUE", pos));
}
throw new ControlDivideByZeroException("divide by zero", pos);
}
return(new ValueInt(a.AsInt().GetValue() / divisor));
}
if (a.IsNumerical() && b.IsNumerical())
{
var divisor = b.AsDecimal().GetValue();
if (divisor == 0)
{
if (environment.IsDefined("DIV_0_VALUE") &&
environment.Get("DIV_0_VALUE", pos) != ValueNull.NULL)
{
return(environment.Get("DIV_0_VALUE", pos));
}
throw new ControlDivideByZeroException("divide by zero", pos);
}
return(new ValueDecimal(a.AsDecimal().GetValue() / divisor));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot divide values", pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
if (args.IsNull("obj"))
{
return(ValueNull.NULL);
}
var obj = args.Get("obj");
var key = args.HasArg("key") ? args.GetFunc("key") : null;
if (obj.IsString())
{
var str = obj.AsString().GetValue();
var start = (int)args.GetInt("start", str.Length - 1).GetValue();
var part = args.GetString("part").GetValue();
return(new ValueInt(str.LastIndexOf(part, start, StringComparison.Ordinal)));
}
if (obj.IsList())
{
var env = environment;
if (key != null)
{
env = environment.NewEnv();
}
var item = args.Get("part");
var list = obj.AsList().GetValue();
var start = (int)args.GetInt("start", list.Count - 1).GetValue();
for (var idx = start; idx >= 0; idx--)
{
var elem = list[idx];
if (key != null)
{
elem = key.Execute(new Args(key.GetArgNames()[0], elem, pos), env, pos);
}
if (elem.IsEquals(item))
{
return(new ValueInt(idx));
}
}
return(new ValueInt(-1));
}
throw new ControlErrorException(new ValueString("ERROR"), "Find_last only works with strings and lists", pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var filename = args.GetString("filename").GetValue();
var encoding = args.GetString("encoding", "UTF-8").GetValue();
var append = ValueBoolean.FALSE;
if (args.HasArg("append"))
{
append = args.Get("append").AsBoolean();
}
return(new ValueOutput(new StreamWriter(filename, append.GetValue(), encoding == "UTF-8" ? Encoding.UTF8 : Encoding.GetEncoding(encoding))));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
if (args.IsNull("x"))
{
return(ValueNull.NULL);
}
if (args.IsNull("y"))
{
return(ValueNull.NULL);
}
if (args.Get("y").IsInt())
{
if (args.Get("x").IsInt())
{
var x = args.GetInt("x").GetValue();
var y = args.GetInt("y").GetValue();
long result = 1;
for (int i = 0; i < y; i++)
{
result *= x;
}
return(new ValueInt(result));
}
else
{
var x = args.GetDecimal("x").GetValue();
var y = args.GetInt("y").GetValue();
decimal result = 1;
for (int i = 0; i < y; i++)
{
result *= x;
}
return(new ValueDecimal(result));
}
}
else
{
return(new ValueDecimal((decimal)Math.Pow((double)args.GetNumerical("x").GetValue(), (double)args.GetNumerical("y").GetValue())));
}
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var a = args.Get("a");
var b = args.Get("b");
if (a.IsNull() || b.IsNull())
{
return(ValueNull.NULL);
}
if (a.IsInt() && b.IsInt())
{
return(new ValueInt(a.AsInt().GetValue() % b.AsInt().GetValue()));
}
if (a.IsNumerical() && b.IsNumerical())
{
return(new ValueDecimal(a.AsDecimal().GetValue() % b.AsDecimal().GetValue()));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot calculate modulus of " + a + " by " + b, pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var lst = args.Get("lst");
var element = args.Get("element");
if (lst.IsList())
{
var list = lst.AsList().GetValue();
for (var i = 0; i < list.Count; i++)
{
if (list[i].IsEquals(element))
{
list.RemoveAt(i);
break;
}
}
return(lst);
}
if (lst.IsSet())
{
var set = lst.AsSet().GetValue();
set.Remove(element);
return(lst);
}
if (lst.IsMap())
{
var map = lst.AsMap().GetValue();
map.Remove(element);
return(lst);
}
if (lst.IsObject())
{
var map = lst.AsObject().value;
map.Remove(element.AsString().GetValue());
return(lst);
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot remove from " + lst.Type(), pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var conn = args.Get("conn");
if (conn.IsInput())
{
conn.AsInput().Close();
}
if (conn.IsOutput())
{
conn.AsOutput().Close();
}
return(ValueNull.NULL);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
if (args.IsNull("str"))
{
return(ValueNull.NULL);
}
var str = args.GetString("str").GetValue();
var fmts = new List <string>();
if (args.HasArg("fmt"))
{
if (args.Get("fmt").IsList())
{
foreach (var fmt_ in args.GetList("fmt").GetValue())
{
fmts.Add(fmt_.AsString().GetValue());
}
}
else
{
fmts.Add(args.GetString("fmt").GetValue());
}
}
else
{
fmts.Add("yyyyMMdd");
}
foreach (var fmt in fmts)
{
try
{
return(new ValueDate(DateTime.ParseExact(str, fmt, DateTimeFormatInfo.InvariantInfo)));
}
catch
{
// continue;
}
}
return(ValueNull.NULL);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var obj = args.Get("obj");
if (obj.IsNull())
{
return(ValueBoolean.FALSE);
}
if (obj.IsNumerical())
{
return(ValueBoolean.TRUE);
}
if (obj.IsString())
{
return(ValueBoolean.From(obj.AsString().GetValue().Length > 0));
}
if (obj.IsList())
{
return(ValueBoolean.From(obj.AsList().GetValue().Count != 0));
}
if (obj.IsSet())
{
return(ValueBoolean.From(obj.AsSet().GetValue().Count != 0));
}
if (obj.IsMap())
{
return(ValueBoolean.From(obj.AsMap().GetValue().Count != 0));
}
if (obj.IsObject())
{
return(ValueBoolean.From(obj.AsObject().value.Count != 0));
}
return(ValueBoolean.TRUE);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var lst = args.Get("lst");
var index = (int)args.GetInt("index").GetValue();
if (lst.IsList())
{
var list = lst.AsList().GetValue();
if (index < 0)
{
index = list.Count + index;
}
if (index >= list.Count)
{
return(ValueNull.NULL);
}
var result = list[index];
list.RemoveAt(index);
return(result);
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot delete from " + lst.Type(), pos);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
var env = lexicalEnv.NewEnv();
for (var i = 0; i < argNames.Count; i++)
{
if (args.HasArg(argNames[i]))
{
env.Put(argNames[i], args.Get(argNames[i]));
}
else if (defValues[i] != null)
{
env.Put(argNames[i], defValues[i].Evaluate(env));
}
else
{
throw new ControlErrorException(new ValueString("ERROR"), "Missing argument " + argNames[i], pos);
}
}
var result = body.Evaluate(env);
if (result.IsReturn())
{
return(result.AsReturn().value);
}
if (result.IsBreak())
{
throw new ControlErrorException(new ValueString("ERROR"), "Cannot use break without surrounding for loop", result.AsBreak().pos);
}
if (result.IsContinue())
{
throw new ControlErrorException(new ValueString("ERROR"), "Cannot use continue without surrounding for loop", result.AsContinue().pos);
}
return(result);
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
return(ValueBoolean.From(!args.Get("obj").IsNull()));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
return(args.Get("obj"));
}
public override Value Execute(Args args, Environment environment, SourcePos pos)
{
if (args.IsNull("fmt"))
{
return(ValueNull.NULL);
}
var fmt = args.GetString("fmt").GetValue();
var arguments = args.Get("args...").AsList().GetValue();
var result = "";
var lastidx = 0;
var pattern = "\\{([0-9]+)(#[^}]+)?\\}";
foreach (Match match in Regex.Matches(fmt, pattern))
{
var start = match.Groups[0].Index;
var end = start + match.Groups[0].Length;
var var = int.Parse(match.Groups[1].Value);
var spec = match.Groups[2].Value;
var width = 0;
var zeroes = false;
var leading = true;
int numbase = 10;
var digits = -1;
if (spec != null && spec != "")
{
spec = spec.Substring(1); // skip #
if (spec.StartsWith("-"))
{
leading = false;
spec = spec.Substring(1);
}
if (spec.StartsWith("0"))
{
zeroes = true;
leading = false;
spec = spec.Substring(1);
}
if (spec.EndsWith("x"))
{
numbase = 16;
spec = spec.Substring(0, spec.Length - 1);
}
int idx = spec.IndexOf('.');
if (idx == -1)
{
digits = -1;
width = int.Parse(spec == "" ? "0" : spec);
}
else
{
digits = int.Parse(spec.Substring(idx + 1));
width = idx == 0 ? 0 : int.Parse(spec.Substring(0, idx));
}
}
string value;
if (numbase != 10)
{
value = string.Format("{0:x}", arguments[var].AsInt().GetValue());
}
else if (digits != -1)
{
value = string.Format("{0:f" + digits + "}", arguments[var].AsDecimal().GetValue());
}
else
{
value = arguments[var].AsString().GetValue();
}
while (value.Length < width)
{
if (leading)
{
value = ' ' + value;
}
else if (zeroes)
{
value = '0' + value;
}
else
{
value = value + ' ';
}
}
if (lastidx < start)
{
result += fmt.Substring(lastidx, start - lastidx);
}
result += value;
lastidx = end;
}
if (lastidx < fmt.Length)
{
result += fmt.Substring(lastidx);
}
return(new ValueString(result));
}
