public SECond(SExprAtomic ha, SExprComp c)
{
if (c.Atomics.Count < 2)
{
throw new VMException("at least 1 branch must be defined", ha);
}
condition = SExpression.Cast(c.Atomics.Pop());
branches = new List <Tuple <SExpression, SExpression> >();
foreach (var a in c.Atomics)
{
var b = a as SExprComp;
if (b == null || b.Atomics.Count < 2)
{
throw new VMException("each branch must be a compound", ha);
}
var cond = b.Atomics.Pop();
if (cond is SExprAtomic &&
((SExprAtomic)cond).Token.TType == SToken.TokenType.ATOMIC &&
(string)((SExprAtomic)cond).Token.TValue == "_")
{
defaultBranch = SExpression.Cast(b.Atomics.Pop());
}
else
{
branches.Add(new Tuple <SExpression, SExpression>(
SExpression.Cast(cond),
SExpression.Cast(b.Atomics.Pop())
));
}
}
}
public SESet(SExprAtomic ha, SExprComp c, bool imm) : base(ha, c)
{
if (c.Atomics.Count < 1)
{
throw new VMException("it takes at least 1 argument", ha);
}
var n = c.Atomics.Pop();
if (n is SExprAtomic && (n as SExprAtomic).Token.TType == SToken.TokenType.ATOMIC)
{
varName = (string)(n as SExprAtomic).Token.TValue;
}
else
{
nameExpr = SExpression.Cast(n);
}
if (c.Atomics.Count > 0)
{
varValue = SExpression.Cast(c.Atomics.Pop());
}
else
{
varValue = new SNull();
}
makeImmutable = imm;
}
public SERegexMatch(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count > 1)
{
regex = SExpression.Cast(c.Atomics.Pop());
text = SExpression.Cast(c.Atomics.Pop());
if (c.Atomics.Count > 0)
{
start = SExpression.Cast(c.Atomics.Pop());
}
else
{
start = new SNumber(0);
}
if (c.Atomics.Count > 0)
{
length = SExpression.Cast(c.Atomics.Pop());
}
else
{
length = new SNumber(-1);
}
}
else
{
throw new VMException("it takes at least 2 arguments", ha);
}
}
public SEInteropGetType(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 1)
{
throw new VMException("it takes 1 argument", ha);
}
typeName = SExpression.Cast(c.Atomics.Pop());
}
public SEUnsafe(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 1)
{
throw new VMException("it takes 1 argument", ha);
}
obj = SExpression.Cast(c.Atomics.Pop());
}
public SEKeys(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 1)
{
throw new VMException("it takes 1 argument");
}
dict = SExpression.Cast(c.Atomics.Pop());
}
public SESub(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 2 && c.Atomics.Count != 3)
{
throw new VMException("it takes 2 or 3 arguments", ha);
}
arguments = (from a in c.Atomics select SExpression.Cast(a)).ToList();
}
public SEStr(SExprAtomic ha, SExprComp c, bool chr) : base(ha, c)
{
if (c.Atomics.Count != 1)
{
throw new VMException("it takes 1 argument");
}
argument = SExpression.Cast(c.Atomics.Pop());
convertChr = chr;
}
public SEDel(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 2)
{
throw new VMException("it takes 2 arguments", ha);
}
host = SExpression.Cast(c.Atomics.Pop());
index = SExpression.Cast(c.Atomics.Pop());
}
public SEInteropNew(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count < 1)
{
throw new VMException("it takes at least 1 argument", ha);
}
type = SExpression.Cast(c.Atomics.Pop());
arguments = c.Atomics.Select(a => SExpression.Cast(a)).ToList();
}
public SESplit(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 2)
{
throw new VMException("it takes 2 arguments", ha);
}
text = SExpression.Cast(c.Atomics.Pop());
delim = SExpression.Cast(c.Atomics.Pop());
}
public SEMultiCore(SExprAtomic ha, SExprComp c, string f) : base(ha, c)
{
argumentExprs = (from a in c.Atomics select SExpression.Cast(a)).ToList();
func = f;
if (argumentExprs.Count < 1)
{
throw new VMException("it takes at least 1 argument", ha);
}
}
public SEPrint(SExprAtomic ha, SExprComp c, string d) : base(ha, c)
{
delim = d;
if (c.Atomics.Count == 0)
{
throw new VMException("it takes at least 1 argument", ha);
}
arguments = (from a in c.Atomics select SExpression.Cast(a)).ToList();
}
public SEGet(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count < 2)
{
throw new VMException("it takes at least 2 arguments", ha);
}
dict = SExpression.Cast(c.Atomics.Pop());
keys = c.Atomics.Select(a => SExpression.Cast(a)).ToList();
}
public SEInteropGetSetMember(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count < 2)
{
throw new VMException("it takes at least 2 arguments", ha);
}
obj = SExpression.Cast(c.Atomics.Pop());
propName = SExpression.Cast(c.Atomics.Pop());
}
public SENum(SExprAtomic ha, SExprComp c, bool asc) : base(ha, c)
{
if (c.Atomics.Count != 1)
{
throw new VMException("it takes 1 argument");
}
argument = SExpression.Cast(c.Atomics.Pop());
convertAsc = asc;
}
public SEFor(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count < 2)
{
throw new VMException("it takes 2 arguments", ha);
}
list = SExpression.Cast(c.Atomics.Pop());
body = SExpression.Cast(c.Atomics.Pop());
}
public SEDict(SExprAtomic ha, SExprComp c) : base(ha, c)
{
values = c.Atomics.Select(a =>
{
if (!(a is SExprComp) || (a as SExprComp).Atomics.Count != 2)
{
throw new VMException("each element of the dict must be a list with 2 elements", ha);
}
return(SExpression.Cast(a));
}).ToList();
}
public SEInteropInvokeStaticMethod(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count < 2)
{
throw new VMException("it takes at least 2 arguments", ha);
}
type = SExpression.Cast(c.Atomics.Pop());
methodName = SExpression.Cast(c.Atomics.Pop());
arguments = c.Atomics.Select(a => SExpression.Cast(a)).ToList();
}
public SEEval(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count != 1 && c.Atomics.Count != 2)
{
throw new VMException("it takes 1 or 2 arguments");
}
text = SExpression.Cast(c.Atomics.Pop());
if (c.Atomics.Count > 0)
{
env = SExpression.Cast(c.Atomics.Pop());
}
}
public SELambda(SExprAtomic ha, SExprComp c)
{
if (c.Atomics.Count < 2)
{
throw new VMException("missing lambda body", ha);
}
if (!(c.Atomics[0] is SExprComp))
{
throw new VMException("the first argument must be the declaration", ha);
}
arguments = SELambda.CompoundToArguments(c.Atomics.Pop() as SExprComp, ha);
body = SExpression.Cast(c.Atomics.Pop());
}
BuildMethodPattern(List <SExpression> args, ExecEnvironment env, SExprAtomic headAtom)
{
List <Type> pattern = new List <Type>();
List <object> arguments = new List <object>();
args.ForEach(arg =>
{
var a = arg.Evaluate(env);
if (a is SList && (a as SList).Get <List <SValue> >().Count == 2)
{
var list = (a as SList).Get <List <SValue> >();
var typeName = list[0] as SString;
if (typeName == null)
{
throw new VMException("type name must be a string", headAtom);
}
var t = Type.GetType(typeName.Get <String>());
pattern.Add(t);
if (t == typeof(Object))
{
arguments.Add(list[1].Underlying);
}
else
{
arguments.Add(Convert.ChangeType(list[1].Underlying, t));
}
}
else
{
if (a is SString)
{
pattern.Add(typeof(string));
arguments.Add((string)a.Underlying);
}
else if (a is SBool)
{
pattern.Add(typeof(bool));
arguments.Add((bool)a.Underlying);
}
else
{
throw new VMException("you must specify a type to avoid ambiguousness", headAtom);
}
}
});
return(new Tuple <List <Type>, List <object> >(pattern, arguments));
}
public SEIf(SExprAtomic ha, SExprComp c)
{
if (c.Atomics.Count == 0)
{
throw new VMException("missing true branch", ha);
}
if (c.Atomics.Count == 1)
{
throw new VMException("missing false branch", ha);
}
condition = SExpression.Cast(c.Atomics.Pop());
trueBranch = SExpression.Cast(c.Atomics.Pop());
falseBranch = SExpression.Cast(c.Atomics.Pop());
}
public SEType(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count == 0)
{
throw new VMException("it takes 1 argument", ha);
}
var n = c.Atomics.Pop();
if (n is SExprAtomic && (n as SExprAtomic).Token.TType == SToken.TokenType.ATOMIC)
{
vname = (string)(n as SExprAtomic).Token.TValue;
}
else
{
nameExpr = SExpression.Cast(n);
}
}
private static SExprComp wrap(SExprAtomic ha, SExprComp c, bool inc)
{
if (c.Atomics.Count != 1)
{
throw new VMException("it takes 1 argument", ha);
}
SExprComp ret = new SExprComp();
SExprComp op = new SExprComp();
ret.Atomics = c.Atomics.Take(1).ToList();
op.Atomics.Add(new SExprAtomic(new SToken(SToken.TokenType.ATOMIC, inc ? "+" : "-")));
op.Atomics.Add(ret.Clone());
op.Atomics.Add(new SExprAtomic(new SToken(SToken.TokenType.NUMBER, new Decimal(1))));
ret.Atomics.Add(op);
return(ret);
}
private static SExprComp wrap(SExprAtomic ha, SExprComp c, string o)
{
if (c.Atomics.Count != 2)
{
throw new VMException("it takes 2 arguments", ha);
}
SExprComp ret = new SExprComp();
SExprComp op = new SExprComp();
ret.Atomics = c.Atomics.Take(1).ToList();
op.Atomics.Add(new SExprAtomic(new SToken(SToken.TokenType.ATOMIC, o)));
op.Atomics.Add(ret.Clone());
op.Atomics.Add(c.Atomics.Skip(1).Take(1).First().Clone());
ret.Atomics.Add(op);
return(ret);
}
public static SExpression Cast(SExprAtomic e)
{
if (e.Token.TType == SToken.TokenType.STRING)
{
return(new SString((string)e.Token.TValue));
}
else if (e.Token.TType == SToken.TokenType.NUMBER)
{
return(new SNumber((decimal)e.Token.TValue));
}
else if (e.Token.TType == SToken.TokenType.SEXPRESSION)
{
return((SExpression)e.Token.TValue);
}
else
{
return(new SEVariable((string)e.Token.TValue, e, null));
}
}
public SERegex(SExprAtomic ha, SExprComp c) : base(ha, c)
{
if (c.Atomics.Count > 0)
{
re = SExpression.Cast(c.Atomics.Pop());
if (c.Atomics.Count > 0)
{
option = SExpression.Cast(c.Atomics.Pop());
}
else
{
option = new SString("None");
}
}
else
{
throw new VMException("it takes 1 or 2 arguments", ha);
}
}
public SERange(SExprAtomic ha, SExprComp c) : base(ha, c)
{
var args = (from v in c.Atomics select SExpression.Cast(v)).ToList();
if (args.Count == 2)
{
start = args[0];
end = args[1];
interval = new SNumber(1);
}
else if (args.Count == 3)
{
start = args[0];
interval = args[1];
end = args[2];
}
else
{
throw new VMException("it takes 2 or 3 arguments", ha);
}
}
public static List <string> CompoundToArguments(SExprComp c, SExprAtomic pos)
{
List <string> ret = new List <string>();
for (var i = 0; i < c.Atomics.Count; i++)
{
var a = c.Atomics[i];
if (!(a is SExprAtomic) || (a as SExprAtomic).Token.TType != SToken.TokenType.ATOMIC)
{
throw new VMException("argument name must be an atom", pos);
}
var name = (string)(a as SExprAtomic).Token.TValue;
if (i != c.Atomics.Count - 1 && name.Length > 3 && name.Substring(name.Length - 3) == "...")
{
throw new VMException("argument list must be at the end of the declaration", pos);
}
ret.Add(name);
}
return(ret);
}