public Expr Parse(ParserContext pcon, object frm)
{
ISeq form = (ISeq)frm;
// (if test then) or (if test then else)
if (form.count() > 4)
{
throw new ParseException("Too many arguments to if");
}
if (form.count() < 3)
{
throw new ParseException("Too few arguments to if");
}
Expr testExpr = Compiler.Analyze(pcon.EvalOrExpr().SetAssign(false), RT.second(form));
Expr thenExpr = Compiler.Analyze(pcon.SetAssign(false), RT.third(form));
Expr elseExpr = Compiler.Analyze(pcon.SetAssign(false), RT.fourth(form));
return(new IfExpr((IPersistentMap)Compiler.SourceSpanVar.deref(), testExpr, thenExpr, elseExpr));
}
public Expr Parse(object frm)
{
ISeq form = (ISeq)frm;
// (if test then) or (if test then else)
if (form.count() > 4)
{
throw new Exception("Too many arguments to if");
}
if (form.count() < 3)
{
throw new Exception("Too few arguments to if");
}
Expr testExpr = Compiler.GenerateAST(RT.second(form));
Expr thenExpr = Compiler.GenerateAST(RT.third(form));
Expr elseExpr = form.count() == 4 ? Compiler.GenerateAST(RT.fourth(form)) : null;
return(new IfExpr(testExpr, thenExpr, elseExpr));
}
public Expr Parse(ParserContext pcon, object form)
{
ISeq sform = (ISeq)form;
// form is one of:
// (. x fieldname-sym)
// (. x 0-ary-method)
// (. x propertyname-sym)
// (. x methodname-sym args)+
// (. x (methodname-sym args?))
// (. x (generic-m
if (RT.Length(sform) < 3)
{
throw new ParseException("Malformed member expression, expecting (. target member ... )");
}
string source = (string)Compiler.SourceVar.deref();
IPersistentMap spanMap = (IPersistentMap)Compiler.SourceSpanVar.deref(); // Compiler.GetSourceSpanMap(form);
Symbol tag = Compiler.TagOf(sform);
// determine static or instance
// static target must be symbol, either fully.qualified.Typename or Typename that has been imported
Type t = HostExpr.MaybeType(RT.second(sform), false);
// at this point, t will be non-null if static
Expr instance = null;
if (t == null)
{
instance = Compiler.Analyze(pcon.EvalOrExpr(), RT.second(sform));
}
bool isZeroArityCall = RT.Length(sform) == 3 && RT.third(sform) is Symbol;
if (isZeroArityCall)
{
PropertyInfo pinfo = null;
FieldInfo finfo = null;
// TODO: Figure out if we want to handle the -propname otherwise.
bool isPropName = false;
Symbol sym = (Symbol)RT.third(sform);
if (sym.Name[0] == '-')
{
isPropName = true;
sym = Symbol.intern(sym.Name.Substring(1));
}
string fieldName = Compiler.munge(sym.Name);
// The JVM version does not have to worry about Properties. It captures 0-arity methods under fields.
// We have to put in special checks here for this.
// Also, when reflection is required, we have to capture 0-arity methods under the calls that
// are generated by StaticFieldExpr and InstanceFieldExpr.
if (t != null)
{
if ((finfo = Reflector.GetField(t, fieldName, true)) != null)
{
return(new StaticFieldExpr(source, spanMap, tag, t, fieldName, finfo));
}
if ((pinfo = Reflector.GetProperty(t, fieldName, true)) != null)
{
return(new StaticPropertyExpr(source, spanMap, tag, t, fieldName, pinfo));
}
if (!isPropName && Reflector.GetArityZeroMethod(t, fieldName, true) != null)
{
return(new StaticMethodExpr(source, spanMap, tag, t, fieldName, null, new List <HostArg>()));
}
throw new MissingMemberException(t.Name, fieldName);
}
else if (instance != null && instance.HasClrType && instance.ClrType != null)
{
Type instanceType = instance.ClrType;
if ((finfo = Reflector.GetField(instanceType, fieldName, false)) != null)
{
return(new InstanceFieldExpr(source, spanMap, tag, instance, fieldName, finfo));
}
if ((pinfo = Reflector.GetProperty(instanceType, fieldName, false)) != null)
{
return(new InstancePropertyExpr(source, spanMap, tag, instance, fieldName, pinfo));
}
if (!isPropName && Reflector.GetArityZeroMethod(instanceType, fieldName, false) != null)
{
return(new InstanceMethodExpr(source, spanMap, tag, instance, fieldName, null, new List <HostArg>()));
}
if (pcon.IsAssignContext)
{
return(new InstanceFieldExpr(source, spanMap, tag, instance, fieldName, null)); // same as InstancePropertyExpr when last arg is null
}
else
{
return(new InstanceZeroArityCallExpr(source, spanMap, tag, instance, fieldName));
}
}
else
{
// t is null, so we know this is not a static call
// If instance is null, we are screwed anyway.
// If instance is not null, then we don't have a type.
// So we must be in an instance call to a property, field, or 0-arity method.
// The code generated by InstanceFieldExpr/InstancePropertyExpr with a null FieldInfo/PropertyInfo
// will generate code to do a runtime call to a Reflector method that will check all three.
//return new InstanceFieldExpr(source, spanMap, tag, instance, fieldName, null); // same as InstancePropertyExpr when last arg is null
//return new InstanceZeroArityCallExpr(source, spanMap, tag, instance, fieldName);
if (pcon.IsAssignContext)
{
return(new InstanceFieldExpr(source, spanMap, tag, instance, fieldName, null)); // same as InstancePropertyExpr when last arg is null
}
else
{
return(new InstanceZeroArityCallExpr(source, spanMap, tag, instance, fieldName));
}
}
}
//ISeq call = RT.third(form) is ISeq ? (ISeq)RT.third(form) : RT.next(RT.next(form));
ISeq call;
List <Type> typeArgs = null;
object fourth = RT.fourth(sform);
if (fourth is ISeq && RT.first(fourth) is Symbol && ((Symbol)RT.first(fourth)).Equals(TypeArgsSym))
{
// We have a type args supplied for a generic method call
// (. thing methodname (type-args type1 ... ) args ...)
typeArgs = ParseGenericMethodTypeArgs(RT.next(fourth));
call = RT.listStar(RT.third(sform), RT.next(RT.next(RT.next(RT.next(sform)))));
}
else
{
call = RT.third(sform) is ISeq ? (ISeq)RT.third(sform) : RT.next(RT.next(sform));
}
if (!(RT.first(call) is Symbol))
{
throw new ParseException("Malformed member exception");
}
string methodName = Compiler.munge(((Symbol)RT.first(call)).Name);
List <HostArg> args = ParseArgs(pcon, RT.next(call));
return(t != null
? (MethodExpr)(new StaticMethodExpr(source, spanMap, tag, t, methodName, typeArgs, args))
: (MethodExpr)(new InstanceMethodExpr(source, spanMap, tag, instance, methodName, typeArgs, args)));
}
public Expr Parse(ParserContext pcon, object form)
{
// (def x) or (def x initexpr) or (def x "docstring" initexpr)
string docstring = null;
if (RT.count(form) == 4 && (RT.third(form) is String))
{
docstring = (String)RT.third(form);
form = RT.list(RT.first(form), RT.second(form), RT.fourth(form));
}
if (RT.count(form) > 3)
{
throw new ParseException("Too many arguments to def");
}
if (RT.count(form) < 2)
{
throw new ParseException("Too few arguments to def");
}
Symbol sym = RT.second(form) as Symbol;
if (sym == null)
{
throw new ParseException("First argument to def must be a Symbol.");
}
//Console.WriteLine("Def {0}", sym.Name);
Var v = Compiler.LookupVar(sym, true);
if (v == null)
{
throw new ParseException("Can't refer to qualified var that doesn't exist");
}
if (!v.Namespace.Equals(Compiler.CurrentNamespace))
{
if (sym.Namespace == null)
{
v = Compiler.CurrentNamespace.intern(sym);
Compiler.RegisterVar(v);
}
//throw new Exception(string.Format("Name conflict, can't def {0} because namespace: {1} refers to: {2}",
// sym, Compiler.CurrentNamespace.Name, v));
else
{
throw new ParseException("Can't create defs outside of current namespace");
}
}
IPersistentMap mm = sym.meta();
bool isDynamic = RT.booleanCast(RT.get(mm, Compiler.DynamicKeyword));
if (isDynamic)
{
v.setDynamic();
}
if (!isDynamic && sym.Name.StartsWith("*") && sym.Name.EndsWith("*") && sym.Name.Length > 2)
{
RT.errPrintWriter().WriteLine("Warning: {0} not declared dynamic and thus is not dynamically rebindable, "
+ "but its name suggests otherwise. Please either indicate ^:dynamic {0} or change the name. ({1}:{2}\n",
sym, Compiler.SourcePathVar.get(), Compiler.LineVar.get());
}
if (RT.booleanCast(RT.get(mm, Compiler.ArglistsKeyword)))
{
IPersistentMap vm = v.meta();
//vm = (IPersistentMap)RT.assoc(vm, Compiler.STATIC_KEY, true);
// drop quote
vm = (IPersistentMap)RT.assoc(vm, Compiler.ArglistsKeyword, RT.second(mm.valAt(Compiler.ArglistsKeyword)));
v.setMeta(vm);
}
Object source_path = Compiler.SourcePathVar.get();
source_path = source_path ?? "NO_SOURCE_FILE";
mm = (IPersistentMap)RT.assoc(mm, RT.LineKey, Compiler.LineVar.get())
.assoc(RT.ColumnKey, Compiler.ColumnVar.get())
.assoc(RT.FileKey, source_path);
//.assoc(RT.SOURCE_SPAN_KEY,Compiler.SOURCE_SPAN.deref());
if (docstring != null)
{
mm = (IPersistentMap)RT.assoc(mm, RT.DocKey, docstring);
}
// Following comment in JVM version
//mm = mm.without(RT.DOC_KEY)
// .without(Keyword.intern(null, "arglists"))
// .without(RT.FILE_KEY)
// .without(RT.LINE_KEY)
// .without(RT.COLUMN_KEY)
// .without(Keyword.intern(null, "ns"))
// .without(Keyword.intern(null, "name"))
// .without(Keyword.intern(null, "added"))
// .without(Keyword.intern(null, "static"));
mm = (IPersistentMap)Compiler.ElideMeta(mm);
Expr meta = mm == null || mm.count() == 0 ? null : Compiler.Analyze(pcon.EvalOrExpr(), mm);
Expr init = Compiler.Analyze(pcon.EvalOrExpr(), RT.third(form), v.Symbol.Name);
bool initProvided = RT.count(form) == 3;
return(new DefExpr(
(string)Compiler.SourceVar.deref(),
Compiler.LineVarDeref(),
Compiler.ColumnVarDeref(),
v, init, meta, initProvided, isDynamic));
}
