private static Value Parse(Lexer lexer)
{
try {
var token = lexer.NextToken();
if (token == "[")
{
var result = new ValueList();
var next = lexer.NextToken();
while (next != "]")
{
lexer.PutBackToken(next);
result.AddItem(Parse(lexer));
next = lexer.NextToken();
if (next != "]")
{
lexer.PutBackToken(next);
lexer.MatchToken(",");
next = lexer.NextToken();
}
}
return(result);
}
if (token == "{")
{
var result = new ValueMap();
var next = lexer.NextToken();
while (next != "}")
{
lexer.PutBackToken(next);
var key = lexer.NextToken();
if (!key.StartsWith("\""))
{
throw new Exception("Expected object key, but got " + key);
}
key = key.Substring(1, key.Length - 2);
lexer.MatchToken(":");
result.AddItem(new ValueString(key), Parse(lexer));
next = lexer.NextToken();
if (next != "}")
{
lexer.PutBackToken(next);
lexer.MatchToken(",");
next = lexer.NextToken();
}
}
return(result);
}
if (token.StartsWith("\""))
{
return(new ValueString(token.Substring(1, token.Length - 2)));
}
if (token == "true" || token == "false")
{
return(ValueBoolean.From(bool.Parse(token)));
}
if (token == "null")
{
return(ValueNull.NULL);
}
if (token.IndexOf('.') == -1)
{
return(new ValueInt(long.Parse(token)));
}
return(new ValueDecimal(decimal.Parse(token)));
} catch (Exception) {
return(null);
}
}
public Value Evaluate(Environment environment)
{
Value value = this.expression.Evaluate(environment);
Value start = this.start.Evaluate(environment);
Value end = this.end != null?this.end.Evaluate(environment) : null;
if (value == ValueNull.NULL)
{
return(ValueNull.NULL);
}
if (value.IsString())
{
var s = value.AsString().GetValue();
int idxStart = (int)start.AsInt().GetValue();
int idxEnd = end == null ? s.Length : (int)end.AsInt().GetValue();
if (idxStart < 0)
{
idxStart = idxStart + s.Length;
}
if (idxEnd < 0)
{
idxEnd = idxEnd + s.Length;
}
if (idxStart < 0)
{
idxStart = 0;
}
if (idxEnd > s.Length)
{
idxEnd = s.Length;
}
return(new ValueString(s.Substring(idxStart, idxEnd - idxStart)));
}
if (value.IsList())
{
var list = value.AsList().GetValue();
int idxStart = (int)start.AsInt().GetValue();
int idxEnd = end == null ? list.Count : (int)end.AsInt().GetValue();
if (idxStart < 0)
{
idxStart = idxStart + list.Count;
}
if (idxEnd < 0)
{
idxEnd = idxEnd + list.Count;
}
if (idxStart < 0)
{
idxStart = 0;
}
if (idxEnd > list.Count)
{
idxEnd = list.Count;
}
var result = new ValueList();
for (int i = idxStart; i < idxEnd; i++)
{
result.AddItem(list[i]);
}
return(result);
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot slice value " + value, this.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.IsDate())
{
if (b.IsDate())
{
return(new ValueInt(a.AsDate().GetValue().Subtract(b.AsDate().GetValue()).Days));
}
return(new ValueDate(a.AsDate().GetValue() - TimeSpan.FromDays((double)args.GetAsDecimal("b").GetValue())));
}
if (a.IsList())
{
var result = new ValueList();
foreach (var item in a.AsList().GetValue())
{
var add = true;
foreach (var val in args.GetAsList("b").GetValue())
{
if (!item.IsEquals(val))
{
continue;
}
add = false;
break;
}
if (add)
{
result.AddItem(item);
}
}
return(result);
}
if (a.IsSet())
{
var result = new ValueSet();
var minus = new SortedSet <Value>(new ComparerValue());
if (b.IsSet())
{
minus = new SortedSet <Value>(b.AsSet().GetValue(), new ComparerValue());
}
else if (b.IsList())
{
foreach (var element in b.AsList().GetValue())
{
minus.Add(element);
}
}
else
{
minus.Add(b);
}
foreach (var element in a.AsSet().GetValue())
{
if (!minus.Contains(element))
{
result.AddItem(element);
}
}
return(result);
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot subtract " + b + " from " + a, pos);
}
public Value Evaluate(Environment environment)
{
var list = expression.Evaluate(environment);
if (list.IsInput())
{
var input = list.AsInput();
Value result = ValueBoolean.TRUE;
string line = null;
try
{
line = input.ReadLine();
while (line != null)
{
var value = new ValueString(line);
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], value);
}
else
{
var vals = value.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
line = input.ReadLine();
}
if (identifiers.Count == 1)
{
environment.Remove(identifiers[0]);
}
else
{
for (var i = 0; i < identifiers.Count; i++)
{
environment.Remove(identifiers[i]);
}
}
}
catch (IOException)
{
throw new ControlErrorException(new ValueString("ERROR"), "Cannot read from input", pos);
}
return(result);
}
if (list.IsList())
{
Value result = ValueBoolean.TRUE;
foreach (var value in list.AsList().GetValue())
{
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], value);
}
else
{
var vals = value.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
if (identifiers.Count == 1)
{
environment.Remove(identifiers[0]);
}
else
{
for (var i = 0; i < identifiers.Count; i++)
{
environment.Remove(identifiers[i]);
}
}
return(result);
}
if (list.IsSet())
{
Value result = ValueBoolean.TRUE;
foreach (var value in list.AsSet().GetValue())
{
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], value);
}
else
{
var vals = value.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
if (identifiers.Count == 1)
{
environment.Remove(identifiers[0]);
}
else
{
for (var i = 0; i < identifiers.Count; i++)
{
environment.Remove(identifiers[i]);
}
}
return(result);
}
if (list.IsMap())
{
Value result = ValueBoolean.TRUE;
if (what == "keys")
{
foreach (var val in list.AsMap().GetValue().Keys.ToList())
{
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], val);
}
else
{
var vals = val.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
}
else if (what == "values")
{
foreach (var val in list.AsMap().GetValue().Values.ToList())
{
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], val);
}
else
{
var vals = val.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
}
else if (what == "entries")
{
foreach (var entry in list.AsMap().GetValue().ToList())
{
ValueList val = new ValueList();
val.AddItem(entry.Key);
val.AddItem(entry.Value);
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], val);
}
else
{
var vals = val.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
}
if (identifiers.Count == 1)
{
environment.Remove(identifiers[0]);
}
else
{
for (var i = 0; i < identifiers.Count; i++)
{
environment.Remove(identifiers[i]);
}
}
return(result);
}
if (list.IsObject())
{
Value result = ValueBoolean.TRUE;
if (what == "keys")
{
foreach (var key in list.AsObject().value.Keys.ToList())
{
Value val = new ValueString(key);
environment.Put(identifiers[0], val);
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
}
else if (what == "values")
{
foreach (var val in list.AsObject().value.Values.ToList())
{
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], val);
}
else
{
var vals = val.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
}
else if (what == "entries")
{
foreach (var entry in list.AsObject().value.ToList())
{
var val = new ValueList();
val.AddItem(new ValueString(entry.Key));
val.AddItem(entry.Value);
if (identifiers.Count == 1)
{
environment.Put(identifiers[0], val);
}
else
{
var vals = val.AsList().GetValue();
for (int i = 0; i < identifiers.Count; i++)
{
environment.Put(identifiers[i], vals[i]);
}
}
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
}
if (identifiers.Count == 1)
{
environment.Remove(identifiers[0]);
}
else
{
for (var i = 0; i < identifiers.Count; i++)
{
environment.Remove(identifiers[i]);
}
}
return(result);
}
if (list.IsString())
{
var str = list.AsString().GetValue();
Value result = ValueBoolean.TRUE;
foreach (var value in str)
{
environment.Put(identifiers[0], new ValueString(value.ToString()));
result = block.Evaluate(environment);
if (result.IsBreak())
{
result = ValueBoolean.TRUE;
break;
}
if (result.IsContinue())
{
result = ValueBoolean.TRUE;
// continue
}
if (result.IsReturn())
{
break;
}
}
environment.Remove(identifiers[0]);
return(result);
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot iterate over " + list, pos);
}
private void CollectFiles(string dir, bool recursive, bool include_path, bool include_dirs, ValueList result)
{
var files = Directory.EnumerateFileSystemEntries(dir);
foreach (var file in files)
{
var isDir = (File.GetAttributes(file) & FileAttributes.Directory) != 0;
if (include_dirs || !isDir)
{
result.AddItem(new ValueString(include_path ? file : Path.GetFileName(file)));
}
if (recursive && isDir)
{
CollectFiles(file, recursive, include_path, include_dirs, result);
}
}
}
public ValueList(ValueList value)
{
((List <Value>) this.value).AddRange(value.value);
}
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.IsList())
{
if (b.IsCollection())
{
return(new ValueList(a.AsList().GetValue()).AddItems(b.AsList().GetValue()));
}
return(new ValueList(a.AsList().GetValue()).AddItem(b));
}
if (a.IsDate() && b.IsNumerical())
{
return(new ValueDate(a.AsDate().GetValue() + TimeSpan.FromDays((double)args.GetAsDecimal("b").GetValue())));
}
if (a.IsSet())
{
if (b.IsCollection())
{
return(new ValueSet(a.AsSet().GetValue()).AddItems(b.AsSet().GetValue()));
}
return(new ValueSet(a.AsSet().GetValue()).AddItem(b));
}
if (b.IsList())
{
var result = new ValueList();
result.AddItem(a);
result.AddItems(b.AsList().GetValue());
return(result);
}
if (b.IsSet())
{
var result = new ValueSet();
result.AddItem(a);
result.AddItems(b.AsSet().GetValue());
return(result);
}
if (a.IsString() && b.IsAtomic() || a.IsAtomic() && b.IsString())
{
return(new ValueString(a.AsString().GetValue() + b.AsString().GetValue()));
}
throw new ControlErrorException(new ValueString("ERROR"), "Cannot add " + a + " and " + b, pos);
}
