public static Expr Parse(ParserContext pcon, ISeq form)
{
pcon = pcon.EvalOrExpr();
Expr fexpr = Compiler.Analyze(pcon, form.first());
VarExpr varFexpr = fexpr as VarExpr;
if (varFexpr != null && varFexpr.Var.Equals(Compiler.InstanceVar) && RT.count(form) == 3)
{
Expr sexpr = Compiler.Analyze(pcon.SetRhc(RHC.Expression), RT.second(form));
ConstantExpr csexpr = sexpr as ConstantExpr;
if (csexpr != null)
{
Type tval = csexpr.Val as Type;
if (tval != null)
{
return(new InstanceOfExpr((string)Compiler.SourceVar.deref(), (IPersistentMap)Compiler.SourceSpanVar.deref(), tval, Compiler.Analyze(pcon, RT.third(form))));
}
}
}
if (varFexpr != null && pcon.Rhc != RHC.Eval)
{
Var v = varFexpr.Var;
object arglists = RT.get(RT.meta(v), Compiler.ArglistsKeyword);
int arity = RT.count(form.next());
for (ISeq s = RT.seq(arglists); s != null; s = s.next())
{
IPersistentVector sargs = (IPersistentVector)s.first();
if (sargs.count() == arity)
{
string primc = FnMethod.PrimInterface(sargs);
if (primc != null)
{
return(Compiler.Analyze(pcon,
RT.listStar(Symbol.intern(".invokePrim"),
((Symbol)form.first()).withMeta(RT.map(RT.TagKey, Symbol.intern(primc))),
form.next())));
}
break;
}
}
}
KeywordExpr kwFexpr = fexpr as KeywordExpr;
if (kwFexpr != null && RT.count(form) == 2 && Compiler.KeywordCallsitesVar.isBound)
{
Expr target = Compiler.Analyze(pcon, RT.second(form));
return(new KeywordInvokeExpr((string)Compiler.SourceVar.deref(), (IPersistentMap)Compiler.SourceSpanVar.deref(), Compiler.TagOf(form), kwFexpr, target));
}
IPersistentVector args = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form.next()); s != null; s = s.next())
{
args = args.cons(Compiler.Analyze(pcon, s.first()));
}
//if (args.count() > Compiler.MAX_POSITIONAL_ARITY)
// throw new ArgumentException(String.Format("No more than {0} args supported", Compiler.MAX_POSITIONAL_ARITY));
return(new InvokeExpr((string)Compiler.SourceVar.deref(),
(IPersistentMap)Compiler.SourceSpanVar.deref(), //Compiler.GetSourceSpanMap(form),
Compiler.TagOf(form),
fexpr,
args));
}
//(case* expr shift mask low high default map<minhash, [test then]> identity?)
//prepared by case macro and presumed correct
//case macro binds actual expr in let so expr is always a local,
//no need to worry about multiple evaluation
public Expr Parse(ParserContext pcon, object frm)
{
ISeq form = (ISeq) frm;
if (pcon.Rhc == RHC.Eval)
return Compiler.Analyze(pcon, RT.list(RT.list(Compiler.FN, PersistentVector.EMPTY, form)),"case__"+RT.nextID());
PersistentVector args = PersistentVector.create(form.next());
Dictionary<int,Expr> tests = new Dictionary<int,Expr>();
Dictionary<int,Expr> thens = new Dictionary<int,Expr>();
LocalBindingExpr testexpr = (LocalBindingExpr)Compiler.Analyze(pcon.SetRhc(RHC.Expression),args.nth(0));
//testexpr.shouldClear = false;
//PathNode branch = new PathNode(PATHTYPE.BRANCH, (PathNode) CLEAR_PATH.get());
foreach ( IMapEntry e in ((IPersistentMap)args.nth(6)) )
{
int minhash = (int)e.key();
IMapEntry me = (IMapEntry)e.val();
Expr testExpr = new ConstantExpr(me.key());
tests[minhash] = testExpr;
Expr thenExpr;
//try
//{
// Var.pushThreadBindings(
// RT.map(CLEAR_PATH, new PathNode(PATHTYPE.PATH,branch)));
thenExpr = Compiler.Analyze(pcon,me.val());
//}
//finally
//{
// Var.popThreadBindings();
//}
thens[minhash] = thenExpr;
}
Expr defaultExpr;
//try
//{
// Var.pushThreadBindings(
// RT.map(CLEAR_PATH, new PathNode(PATHTYPE.PATH,branch)));
defaultExpr = Compiler.Analyze(pcon,args.nth(5));
//}
//finally
//{
// Var.popThreadBindings();
//}
return new CaseExpr(
(IPersistentMap) Compiler.SOURCE_SPAN.deref(),
testexpr,
(int)args.nth(1),
(int)args.nth(2),
(int)args.nth(3),
(int)args.nth(4),
defaultExpr,
tests,
thens,
RT.booleanCast(args.nth(7)));
}
public static Expr Parse(ParserContext pcon, ISeq form)
{
bool tailPosition = Compiler.InTailCall(pcon.Rhc);
pcon = pcon.EvalOrExpr();
Expr fexpr = Compiler.Analyze(pcon, form.first());
VarExpr varFexpr = fexpr as VarExpr;
if (varFexpr != null && varFexpr.Var.Equals(Compiler.InstanceVar) && RT.count(form) == 3)
{
Expr sexpr = Compiler.Analyze(pcon.SetRhc(RHC.Expression), RT.second(form));
ConstantExpr csexpr = sexpr as ConstantExpr;
if (csexpr != null)
{
Type tval = csexpr.Val as Type;
if (tval != null)
{
return(new InstanceOfExpr((string)Compiler.SourceVar.deref(), (IPersistentMap)Compiler.SourceSpanVar.deref(), tval, Compiler.Analyze(pcon, RT.third(form))));
}
}
}
if (RT.booleanCast(Compiler.GetCompilerOption(Compiler.DirectLinkingKeyword)) &&
varFexpr != null &&
pcon.Rhc != RHC.Eval)
{
Var v = varFexpr.Var;
if (!v.isDynamic() && !RT.booleanCast(RT.get(v.meta(), Compiler.RedefKeyword, false)) && !RT.booleanCast(RT.get(v.meta(), RT.DeclaredKey, false)))
{
Symbol formTag = Compiler.TagOf(form);
object arglists = RT.get(RT.meta(v), Compiler.ArglistsKeyword);
int arity = RT.count(form.next());
object sigtag = SigTag(arity, v);
object vtag = RT.get(RT.meta(v), RT.TagKey);
StaticInvokeExpr ret = StaticInvokeExpr.Parse(v, RT.next(form), formTag ?? sigtag ?? vtag) as StaticInvokeExpr;
if (ret != null && !((Compiler.IsCompiling || Compiler.IsCompilingDefType) && GenContext.IsInternalAssembly(ret.Method.DeclaringType.Assembly)))
{
//Console.WriteLine("invoke direct: {0}", v);
return(ret);
}
//Console.WriteLine("NOT direct: {0}", v);
}
}
if (varFexpr != null && pcon.Rhc != RHC.Eval)
{
Var v = varFexpr.Var;
object arglists = RT.get(RT.meta(v), Compiler.ArglistsKeyword);
int arity = RT.count(form.next());
for (ISeq s = RT.seq(arglists); s != null; s = s.next())
{
IPersistentVector sargs = (IPersistentVector)s.first();
if (sargs.count() == arity)
{
string primc = FnMethod.PrimInterface(sargs);
if (primc != null)
{
return(Compiler.Analyze(pcon,
((IObj)RT.listStar(Symbol.intern(".invokePrim"),
((Symbol)form.first()).withMeta(RT.map(RT.TagKey, Symbol.intern(primc))),
form.next())).withMeta((IPersistentMap)RT.conj(RT.meta(v), RT.meta(form)))));
}
break;
}
}
}
KeywordExpr kwFexpr = fexpr as KeywordExpr;
if (kwFexpr != null && RT.count(form) == 2 && Compiler.KeywordCallsitesVar.isBound)
{
Expr target = Compiler.Analyze(pcon, RT.second(form));
return(new KeywordInvokeExpr((string)Compiler.SourceVar.deref(), (IPersistentMap)Compiler.SourceSpanVar.deref(), Compiler.TagOf(form), kwFexpr, target));
}
IPersistentVector args = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form.next()); s != null; s = s.next())
{
args = args.cons(Compiler.Analyze(pcon, s.first()));
}
//if (args.count() > Compiler.MAX_POSITIONAL_ARITY)
// throw new ArgumentException(String.Format("No more than {0} args supported", Compiler.MAX_POSITIONAL_ARITY));
return(new InvokeExpr((string)Compiler.SourceVar.deref(),
(IPersistentMap)Compiler.SourceSpanVar.deref(), //Compiler.GetSourceSpanMap(form),
Compiler.TagOf(form),
fexpr,
args,
tailPosition));
}