protected ILithpOpChainMember mapParam(dynamic P, LithpOpChain chain, string fnName)
{
var result = mapParamInner(P, chain, fnName);
parserDebug("mapParam({0}) :: {1}", P, result);
return(result);
}
public LithpPrimitive Invoke(LithpList parameters, LithpOpChain state, LithpInterpreter interp)
{
LithpOpChain parent;
if (body.Scoped)
{
parent = body;
}
else
{
parent = state;
}
LithpOpChain chain = new LithpOpChain(parent, body);
// Arity star functions pass all arguments in first parameter
if (arity.HasValue == false)
{
parameters = LithpList.New(parameters);
}
parameters.Each((Value, Index) =>
{
if (Index < this.parameters.Length)
{
chain.Closure.SetImmediate(this.parameters[Index], Value);
}
});
chain.FunctionEntry = name;
return(interp.Run(chain));
}
public LithpFunctionDefinition CloneWithScope(LithpOpChain state)
{
LithpOpChain body = this.body.CloneWithScope(state);
LithpFunctionDefinition fnNew = new LithpFunctionDefinition(body.Parent, name, body, parameters);
return(fnNew);
}
public LithpFunctionDefinition(LithpOpChain parent, string name,
LithpOpChain body, string[] parameters)
{
this.name = name;
this.body = body;
this.parameters = parameters;
Match x = Regex.Match(name, @"/(\d+|\*)$");
if (x == Match.Empty)
{
arity = parameters.Count();
this.name += "/" + arity.Value.ToString();
}
else
{
string strArity = x.Groups[1].Value;
if (strArity == "*")
{
arity = null;
}
else
{
arity = int.Parse(strArity);
}
}
}
public LithpOpChain Finalize()
{
LithpOpChain chain = new LithpOpChain();
foreach (dynamic x in ops)
{
ILithpOpChainMember c = convert(chain, x);
chain.Add(c);
}
return(chain);
}
protected ILithpOpChainMember mapParamInner(JValue v, LithpOpChain chain, string fnName)
{
Classification cls = classify(v);
string strV = v.ToString();
parserDebug("Classified: {0}", cls.ToString());
if (cls.HasFlag(Classification.STRING_DOUBLE) || cls.HasFlag(Classification.STRING_SINGLE))
{
strV = strV.Substring(1, strV.Length - 2);
string parsed = LithpParser.ParseEscapes(strV);
if (cls.HasFlag(Classification.STRING_DOUBLE))
{
return(new LithpLiteral(new LithpString(parsed)));
}
else if (cls.HasFlag(Classification.STRING_SINGLE))
{
return(LithpAtom.Atom(parsed));
}
}
else if (cls.HasFlag(Classification.VARIABLE))
{
switch (fnName)
{
case "get":
case "set":
case "var":
return(new LithpVariableReference(strV));
default:
return(LithpFunctionCall.New("get/1", new LithpVariableReference(strV)));
}
}
else if (cls.HasFlag(Classification.NUMBER))
{
if (cls.HasFlag(Classification.NUMBER_INTEGER))
{
return(new LithpLiteral(new LithpInteger(strV)));
}
else if (cls.HasFlag(Classification.NUMBER_FLOAT))
{
return(new LithpLiteral(new LithpFloat(strV)));
}
else
{
throw new NotImplementedException();
}
}
else if (cls.HasFlag(Classification.ATOM))
{
return(new LithpLiteral(LithpAtom.Atom(strV)));
}
throw new NotImplementedException();
}
protected ILithpOpChainMember convert(LithpOpChain chain, JObject curr)
{
JArray fncode = (JArray)curr["code"];
JArray fnparams = (JArray)curr["_fnparams"];
List <string> defParams = new List <string>();
foreach (JValue p in fnparams)
{
defParams.Add(p.ToString());
parserDebug("Param: {0}", p.ToString());
}
parserDebug("FunctionDef with params {0}, code: {1}", defParams.ToArray(), fncode);
LithpOpChain defBody = (LithpOpChain)convert(chain, fncode);
string name = "anonymous:" + (AnonymousFnCounter++).ToString();
ILithpOpChainMember def = new LithpFunctionDefinition(chain, name, defBody, defParams.ToArray());
parserDebug("FnDef created: {0}", def);
return(def);
}
protected ILithpOpChainMember convert(LithpOpChain chain, JArray curr)
{
var eleFirst = curr[0];
Classification clsFirst = classify(eleFirst);
if (curr.Count == 0)
{
throw new NotImplementedException();
}
parserDebug(" First element: {0}", eleFirst);
parserDebug(" Classified: {0}", clsFirst.ToString());
if (curr.Count == 0)
{
throw new NotImplementedException();
}
if (clsFirst.HasFlag(Classification.STRING_SINGLE))
{
// Convert to a (call (get 'FnName') Params...)
parserDebug("STRING_SINGLE, convert to FunctionCall");
JValue v = eleFirst as JValue;
string tmp = v.ToString();
eleFirst = tmp.Substring(1, tmp.Length - 2);
clsFirst = classify(eleFirst);
parserDebug(" First element: {0}", eleFirst);
parserDebug(" Re-Classified: {0}", clsFirst.ToString());
}
if (clsFirst.HasFlag(Classification.ATOM))
{
// Function call
parserDebug(" PARSE TO FUNCTIONCALL: {0}", curr);
var skipped = curr.Skip(1);
LithpList parameters = new LithpList();
foreach (var x in skipped)
{
var y = mapParam(x, chain, eleFirst.ToString());
var z = y as LithpPrimitive;
if ((object)z == null)
{
Debug.WriteLine("Failed to convert");
}
parameters.Add(z);
}
if (parameters.Count == 0 && clsFirst.HasFlag(Classification.NUMBER))
{
parserDebug("CONVERT TO LITERAL");
return(this.mapParam(eleFirst, chain, eleFirst.ToString()));
}
else
{
string plen = parameters.Count.ToString();
if (LithpParser.arityBuiltins.ContainsKey(eleFirst.ToString()))
{
plen = LithpParser.arityBuiltins[eleFirst.ToString()];
}
parserDebug("FUNCTIONCALL {0}/{1}", eleFirst, plen);
string name = eleFirst.ToString() + "/" + plen;
return(new LithpFunctionCall(name, parameters));
}
}
else if (curr.Count > 0)
{
// Must be an OpChain
parserDebug(" PARSE TO OPCHAIN");
LithpOpChain newChain = new LithpOpChain(chain);
newChain.Closure.TopMost = chain.Closure.TopMost ?? chain.Closure;
for (int i = 0; i < curr.Count; i++)
{
parserDebug("Member {0} of chain: {1}", i, curr[i]);
newChain.Add(mapParam(curr[i], chain, eleFirst.ToString()));
}
return(newChain);
}
throw new NotImplementedException();
}
protected ILithpOpChainMember mapParamInner(JObject o, LithpOpChain chain, string fnName)
{
return(convert(chain, o));
}
protected ILithpOpChainMember mapParamInner(JArray arr, LithpOpChain chain, string fnName)
{
return(convert(chain, arr));
}
public LithpPrimitive convert(LithpOpChain chain, object curr)
{
}
public LithpPrimitive mapParamInner(List <string> P, LithpOpChain chain, string fnName)
{
}
public LithpPrimitive Invoke(LithpList parameters, LithpOpChain state,
LithpInterpreter interp)
{
return(fn_body(parameters, state, interp));
}
public static LithpFunctionDefinition New(LithpOpChain parent, string name,
LithpOpChain body, params string[] parameters)
{
return(new LithpFunctionDefinition(parent, name, body, parameters));
}
