public static LithpPrimitive BitwiseNot(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpInteger n = (LithpInteger)parameters[0];
return(new LithpInteger((n + 1) * -1));
}
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 Scope(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpFunctionDefinition def = (LithpFunctionDefinition)parameters[0];
return(def.CloneWithScope(state));
}
public static LithpPrimitive Head(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpList value = (LithpList)parameters[0];
return(value[0]);
}
public static LithpPrimitive Tail(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
LithpList value = (LithpList)parameters[0];
return(new LithpList(value.Skip(1).ToArray()));
}
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 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 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 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 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 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 Assert(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
if (parameters[0] == LithpAtom.False)
{
throw new Exception("Assert failed");
}
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 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);
}
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 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 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);
}
public static LithpPrimitive While(LithpList Values, LithpOpChain state,
LithpInterpreter interp)
{
LithpOpChain test = (LithpOpChain)Values[0];
LithpOpChain action = (LithpOpChain)Values[1];
test.Parent = state;
test.Closure.TopMost = state.Closure.TopMost;
test.Closure.Parent = state.Closure;
action.Parent = state;
action.Closure.TopMost = state.Closure.TopMost;
action.Closure.Parent = state.Closure;
test.Rewind();
action.Rewind();
while (interp.Run(test) == LithpAtom.True)
{
test.Rewind();
action.Rewind();
interp.Run(action);
}
return(LithpAtom.Nil);
}
static void Main(string[] args)
{
// Initialize LithpBuiltins now
LithpBuiltins builtins = new LithpBuiltins();
LithpInterpreter interp = new LithpInterpreter();
// Initialize parser
LithpJsonParser.Test();
var watch = Stopwatch.StartNew();
if (false)
{
RunTests();
}
var sampleFactorial = LoadSample("factorial.ast");
var sampleScope = LoadSample("scope.ast");
var sampleComplex = LoadSample("complex.ast");
var sampleIntegral2 = LoadSample("integral2.ast");
var sampleWhile = LoadSample("while.ast");
var runWatch = Stopwatch.StartNew();
interp.Run(sampleFactorial);
interp.Run(sampleScope);
interp.Run(sampleComplex);
interp.Run(sampleIntegral2);
interp.Run(sampleWhile);
interp.Run(LoadSample("var_args.ast"));
interp.Run(LoadSample("recurse.ast"));
runWatch.Stop();
Console.WriteLine("Run finished: {0} function calls in {1}ms", LithpInterpreter.FunctionCalls, runWatch.ElapsedMilliseconds);
watch.Stop();
Console.WriteLine("Tests finished in {0}ms, hit enter", watch.ElapsedMilliseconds);
#if DEBUG
Console.ReadLine();
#endif
}
public static LithpPrimitive Undefined(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
return(LithpAtom.Atom("undefined"));
}
static void RunTests()
{
LithpOpChain chain = new LithpOpChain();
LithpInteger one = 1;
LithpAtom test = "test";
LithpDict dict = new LithpDict();
dict["foo"] = "bar";
dict["num"] = 1;
dict["list"] = LithpList.New("Hello, world!", one, test);
Console.WriteLine(dict.ToLiteral());
LithpFunctionCall fncall = LithpFunctionCall.New("print/*", dict);
Console.WriteLine("fncall tostring: {0}", fncall);
LithpBuiltins builtins = new LithpBuiltins();
LithpInterpreter interp = new LithpInterpreter();
builtins[fncall.Function].Invoke(fncall.Parameters, chain, interp);
// Now put it all together
chain.Add(fncall);
chain.ImportBuiltins(builtins);
Console.WriteLine("Result of print: {0}", interp.Run(chain));
// More complex
LithpFunctionCall addStrings = LithpFunctionCall.New("+/*", "foo", "bar");
LithpFunctionCall printAddString = LithpFunctionCall.New("print/*",
"Adding two strings: ", addStrings);
chain.Add(printAddString);
interp.Run(chain);
chain.Add(addStrings);
Console.WriteLine("Result of add strings: {0}", interp.Run(chain));
LithpFunctionCall setVar = LithpFunctionCall.New("set/2",
new LithpVariableReference("Test"), "Foo");
LithpFunctionCall printVar = LithpFunctionCall.New("print/*",
"Value of Test:", LithpFunctionCall.New(
"get/1", new LithpVariableReference("Test")
));
chain.Add(setVar);
chain.Add(printVar);
// Now run entire chain from the start
chain.Rewind();
interp.Run(chain);
// Try a user-defined function
LithpOpChain addBody = new LithpOpChain(chain);
addBody.Add(LithpFunctionCall.New(
LithpAtom.Atom("+/*"),
LithpFunctionCall.New("get/1", new LithpVariableReference("A")),
LithpFunctionCall.New("get/1", new LithpVariableReference("B"))
));
chain.Add(LithpFunctionCall.New("def/2",
LithpAtom.Atom("add"),
LithpFunctionDefinition.New(chain, "add", addBody, "A", "B")
));
chain.Add(LithpFunctionCall.New("print/*",
"Calling user function add:", LithpFunctionCall.New(
"add/2", 2, 5
)
));
interp.Run(chain);
}
public static LithpPrimitive Modulo(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
return(parameters[0] % parameters[1]);
}
public static LithpPrimitive Sub(LithpList Values, LithpOpChain state,
LithpInterpreter interp)
{
return(ApplyAction((A, B, X, Y) => A - B, Values, state, interp));
}
public static LithpPrimitive Dict(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
return(new LithpDict());
}
