public LithpOpChain(LithpOpChain parent, LithpOpChain body, bool scoped)
: base(body.ToArray())
{
Closure = new LithpClosure(parent.Closure);
Parent = parent;
Scoped = scoped;
}
public static LithpPrimitive Get(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpPrimitive name = CallBuiltin(Head, state, interp, parameters);
return(state.Closure.Get(name));
}
public static LithpPrimitive Tail(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpList value = (LithpList)parameters[0];
return(new LithpList(value.Skip(1).ToArray()));
}
public LithpOpChain CallImmediate()
{
LithpOpChain ch = new LithpOpChain(Parent, this);
ch.IsImmediate = true;
return(ch);
}
public static LithpPrimitive Head(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpList value = (LithpList)parameters[0];
return(value[0]);
}
public static LithpPrimitive Round(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpFloat n = (LithpFloat)parameters[0].Cast(LithpType.FLOAT);
return(new LithpInteger(Convert.ToUInt64(Math.Round(n.value))));
}
public static LithpPrimitive BitwiseNot(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpInteger n = (LithpInteger)parameters[0];
return(new LithpInteger((n + 1) * -1));
}
public static LithpPrimitive Scope(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpFunctionDefinition def = (LithpFunctionDefinition)parameters[0];
return(def.CloneWithScope(state));
}
public static LithpPrimitive DictPresent(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpDict dict = (LithpDict)parameters[0];
LithpString key = (LithpString)parameters[1].Cast(LithpType.STRING);
return(dict.ContainsKey(key) ? LithpAtom.True : LithpAtom.False);
}
public static LithpPrimitive DictGet(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpDict dict = (LithpDict)parameters[0];
LithpString key = (LithpString)parameters[1].Cast(LithpType.STRING);
return(dict[key]);
}
public static LithpPrimitive Repeat(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpString str = (LithpString)parameters[0];
LithpInteger n = (LithpInteger)parameters[1].Cast(LithpType.INTEGER);
return(new LithpString(new string(str.Value[0], n)));
}
public static LithpPrimitive BitwiseXor(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpInteger a = (LithpInteger)parameters[0];
LithpInteger b = (LithpInteger)parameters[1];
return(new LithpInteger(a ^ b));
}
public static LithpPrimitive ParseInt(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpString str = (LithpString)parameters[0].Cast(LithpType.STRING);
string dropDecimals = Regex.Replace(str, @"[.][0-9]+$", "");
return(new LithpInteger(dropDecimals));
}
public static LithpPrimitive Recurse(LithpList Values, LithpOpChain state,
LithpInterpreter interp)
{
var Target = state.Parent;
while (Target && Target.FunctionEntry == null)
{
Target = Target.Parent;
}
if (!Target)
{
throw new Exception("Function entry not found");
}
// Rewind the target opchain
Target.Rewind();
// Get the OpChain function name with arity
string FnAndArity = Target.FunctionEntry;
ILithpFunctionDefinition def;
if (state.Closure.TopMost.IsDefined(FnAndArity))
{
def = (ILithpFunctionDefinition)state.Closure.TopMost[FnAndArity];
}
else if (state.Closure.IsDefinedAny(FnAndArity))
{
def = (ILithpFunctionDefinition)state.Closure[FnAndArity];
}
else
{
FnAndArity = Target.FunctionEntry + "/*";
if (state.Closure.TopMost.IsDefined(FnAndArity))
{
def = (ILithpFunctionDefinition)state.Closure.TopMost[FnAndArity];
}
else if (state.Closure.IsDefinedAny(FnAndArity))
{
def = (ILithpFunctionDefinition)state.Closure[FnAndArity];
}
else
{
throw new MissingMethodException();
}
}
// Set parameters for given function
int i = 0;
foreach (string p in def.Parameters)
{
Target.Closure.SetImmediate(p, Values[i]);
i++;
}
// Return nothing
return(LithpAtom.Nil);
}
public static LithpPrimitive If2(LithpList Values, LithpOpChain state,
LithpInterpreter interp)
{
if (Values[0] == LithpAtom.True)
{
return(getIfResult(Values[1]));
}
return(LithpAtom.Nil);
}
public static LithpPrimitive Assert(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
if (parameters[0] == LithpAtom.False)
{
throw new Exception("Assert failed");
}
return(LithpAtom.Nil);
}
public static LithpPrimitive IndexSet(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpList list = (LithpList)parameters[0];
LithpInteger index = (LithpInteger)parameters[1];
LithpPrimitive value = parameters[2];
list[index] = value;
return(list);
}
public LithpList ResolveParameters(LithpFunctionCall call, LithpOpChain chain)
{
LithpList result = new LithpList();
foreach (var x in call.Parameters)
{
result.Add((LithpPrimitive)resolve((LithpPrimitive)x, chain));
}
return(result);
}
public static LithpPrimitive Set(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpPrimitive name = CallBuiltin(Head, state, interp, parameters);
LithpList tail = (LithpList)CallBuiltin(Tail, state, interp, parameters);
LithpPrimitive value = CallBuiltin(Head, state, interp, tail);
state.Closure.Set(name, value);
return(value);
}
static LithpOpChain LoadSample(string file)
{
var compileWatch = Stopwatch.StartNew();
LithpOpChain chain = LithpJsonParser.LoadSample(file);
chain.ImportBuiltins(Builtins);
compileWatch.Stop();
Console.WriteLine("Compile for {1} finished in {0}ms",
compileWatch.ElapsedMilliseconds, file);
return(chain);
}
public static LithpPrimitive Print(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpPrimitive result = ApplyAction((A, B, X, Y) =>
{
return(A.ToString() + " " + B.ToString());
}, parameters, state, interp);
Console.WriteLine(result.ToString());
return(LithpAtom.Nil);
}
public static LithpPrimitive CompareOr(LithpList Values, LithpOpChain state,
LithpInterpreter interp)
{
foreach (var x in Values)
{
if (Values[0] == LithpAtom.True)
{
return(LithpAtom.True);
}
}
return(LithpAtom.False);
}
protected static LithpPrimitive ApplyAction(LithpAction action, LithpList list,
LithpOpChain state, LithpInterpreter interp)
{
LithpPrimitive value = CallBuiltin(Head, state, interp, list);
LithpList tail = (LithpList)CallBuiltin(Tail, state, interp, list);
foreach (var x in tail)
{
value = action(value, x, state, interp);
}
return(value);
}
public static LithpOpChain Factorial()
{
// (
LithpOpChain result = new LithpOpChain();
// (if (== 1 N) (
// (1)
// ) (else (
// (* N (fac (- N 1)))
// )))
LithpOpChain facBody = new LithpOpChain(result);
LithpOpChain return1 = new LithpOpChain(facBody);
return1.Add(new LithpLiteral(1));
LithpOpChain elseBody = new LithpOpChain(facBody);
elseBody.Add(
LithpFunctionCall.New("*/*",
LithpFunctionCall.New("get/1", new LithpVariableReference("N")),
LithpFunctionCall.New("fac/1",
LithpFunctionCall.New("-/*",
LithpFunctionCall.New("get/1", new LithpVariableReference("N")),
new LithpLiteral(1)
)
)
)
);
facBody.Add(
LithpFunctionCall.New("if/3",
LithpFunctionCall.New("==/2",
new LithpLiteral(1),
LithpFunctionCall.New("get/1", new LithpVariableReference("N"))
),
return1,
LithpFunctionCall.New("else/1", elseBody)
)
);
// (def fac #N :: (
LithpFunctionCall def = LithpFunctionCall.New("def/2", LithpAtom.Atom("fac"),
LithpFunctionDefinition.New(result, "fac", facBody, "N")
);
// )
result.Add(def);
int n;
#if DEBUG
n = 10;
#else
n = 500;
#endif
result.Add(LithpFunctionCall.New("print/*", "Factorial result: ", LithpFunctionCall.New("fac/1", n)));
return(result);
}
public static LithpPrimitive DictKeys(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpDict dict = (LithpDict)parameters[0];
LithpList keys = new LithpList();
foreach (var x in dict.Keys)
{
keys.Add(x);
}
return(keys);
}
public static LithpPrimitive SquareRoot(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
switch (parameters[0].LithpType())
{
case LithpType.INTEGER:
return(((LithpInteger)(parameters[0])).Sqrt());
case LithpType.FLOAT:
return(((LithpFloat)(parameters[0])).Sqrt());
default:
throw new NotImplementedException();
}
}
public static LithpPrimitive Call(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpPrimitive def = parameters[0];
LithpList defParams = (LithpList)Tail(LithpList.New(parameters), state, interp);
switch (def.LithpType())
{
case LithpType.FN_NATIVE:
return(((LithpFunctionDefinitionNative)def).Invoke(defParams, state, interp));
case LithpType.FN:
return(((LithpFunctionDefinition)def).Invoke(defParams, state, interp));
case LithpType.ATOM:
case LithpType.STRING:
string strName = def.ToString();
ILithpFunctionDefinition search;
if ((object)state.Closure.TopMost != null && state.Closure.TopMost.IsDefined(strName))
{
search = (ILithpFunctionDefinition)state.Closure.TopMost[strName];
}
else if (state.Closure.IsDefined(strName))
{
search = (ILithpFunctionDefinition)state.Closure[strName];
}
else
{
string arityStar = strName + "/*";
if ((object)state.Closure.TopMost != null && state.Closure.TopMost.IsDefined(arityStar))
{
search = (ILithpFunctionDefinition)state.Closure.TopMost[arityStar];
}
else if (state.Closure.IsDefined(arityStar))
{
search = (ILithpFunctionDefinition)state.Closure[arityStar];
}
else
{
throw new MissingMethodException();
}
}
return(search.Invoke(defParams, state, interp));
default:
throw new NotImplementedException();
}
}
public static LithpPrimitive Def(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
ILithpPrimitive name = parameters[0];
if (name.LithpType() != LithpType.ATOM)
{
throw new ArgumentException("Function name must be an atom");
}
if (parameters[1].LithpType() != LithpType.FN)
{
throw new ArgumentException("Function body must be a FunctionDefinition");
}
LithpFunctionDefinition body = (LithpFunctionDefinition)parameters[1];
body.SetName(parameters[0]);
state.Closure.SetImmediate(body.Name, body);
return(body);
}
private ILithpPrimitive resolve(ILithpPrimitive current, LithpOpChain chain)
{
switch (current.LithpType())
{
case LithpType.LITERAL:
return(((LithpLiteral)current).Value);
case LithpType.ATOM:
case LithpType.DICT:
case LithpType.INTEGER:
case LithpType.LIST:
case LithpType.STRING:
case LithpType.FN:
case LithpType.FN_NATIVE:
case LithpType.OPCHAIN:
return(current);
case LithpType.FUNCTIONCALL:
LithpFunctionCall call = (LithpFunctionCall)current;
LithpList resolved = ResolveParameters(call, chain);
LithpPrimitive value = InvokeResolved(call, resolved, chain);
if (value.LithpType() == LithpType.OPCHAIN)
{
LithpOpChain subchain = (LithpOpChain)value;
if (subchain.IsImmediate)
{
value = this.Run(new LithpOpChain(chain, subchain));
}
}
return(value);
case LithpType.VAR:
// TODO: Could just lookup the value now
LithpVariableReference v = (LithpVariableReference)current;
return(new LithpString(v.Name));
default:
throw new NotImplementedException();
}
}
public LithpPrimitive Run(LithpOpChain chain)
{
ILithpPrimitive value = LithpAtom.Atom("nil");
while (chain.AtEnd() == false)
{
ILithpOpChainMember current = chain.Next();
switch (current.LithpType())
{
case LithpType.OPCHAIN:
value = this.Run(new LithpOpChain(chain, (LithpOpChain)current));
break;
case LithpType.FUNCTIONCALL:
LithpFunctionCall call = (LithpFunctionCall)current;
LithpList resolved = ResolveParameters(call, chain);
value = InvokeResolved(call, resolved, chain);
if (value.LithpType() == LithpType.OPCHAIN)
{
LithpOpChain subchain = (LithpOpChain)value;
value = this.Run(new LithpOpChain(chain, subchain));
}
break;
case LithpType.LITERAL:
value = ((LithpLiteral)current).Value;
break;
case LithpType.FN:
case LithpType.FN_NATIVE:
value = current;
break;
default:
throw new NotImplementedException();
}
}
return((LithpPrimitive)value);
}
