private void EmitExprForInts(ObjExpr objx, CljILGen ilg, Type exprType, Label defaultLabel)
{
if (exprType == null)
{
if (RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Performance warning, {0}:{1}:{2} - case has int tests, but tested expression is not primitive.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(_sourceSpan), Compiler.GetColumnFromSpanMap(_sourceSpan));
}
_expr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Call, Compiler.Method_Util_IsNonCharNumeric);
ilg.Emit(OpCodes.Brfalse, defaultLabel);
_expr.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Call, Compiler.Method_Util_ConvertToInt);
EmitShiftMask(ilg);
}
else if (exprType == typeof(long) ||
exprType == typeof(int) ||
exprType == typeof(short) ||
exprType == typeof(byte) ||
exprType == typeof(ulong) ||
exprType == typeof(uint) ||
exprType == typeof(ushort) ||
exprType == typeof(sbyte))
{
_expr.EmitUnboxed(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Conv_I4);
EmitShiftMask(ilg);
}
else
{
ilg.Emit(OpCodes.Br, defaultLabel);
}
}
protected InstanceFieldOrPropertyExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string memberName, TInfo tinfo)
{
_source = source;
_spanMap = spanMap;
_target = target;
_memberName = memberName;
_tinfo = tinfo;
_tag = tag;
_targetType = target.HasClrType ? target.ClrType : null;
// Java version does not include check on _targetType
// However, this seems consistent with the checks in the generation code.
if ((_targetType == null || _tinfo == null) && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
if (_targetType == null)
{
RT.errPrintWriter().WriteLine("Reflection warning, {0}:{1}:{2} - reference to field/property {3} can't be resolved.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(_spanMap), Compiler.GetColumnFromSpanMap(_spanMap), _memberName);
}
else
{
RT.errPrintWriter().WriteLine("Reflection warning, {0}:{1}:{2} - reference to field/property {3} on {4} can't be resolved.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(_spanMap), Compiler.GetColumnFromSpanMap(_spanMap), _memberName, _targetType.FullName);
}
}
}
public CaseExpr(IPersistentMap sourceSpan, LocalBindingExpr expr, int shift, int mask, int low, int high, Expr defaultExpr,
SortedDictionary <int, Expr> tests, Dictionary <int, Expr> thens, Keyword switchType, Keyword testType, IPersistentSet skipCheck)
{
_sourceSpan = sourceSpan;
_expr = expr;
_shift = shift;
_mask = mask;
_low = low;
_high = high;
_defaultExpr = defaultExpr;
_tests = tests;
_thens = thens;
if (switchType != _compactKey && switchType != _sparseKey)
{
throw new ArgumentException("Unexpected switch type: " + switchType);
}
_switchType = switchType;
if (testType != _intKey && testType != _hashEquivKey && testType != _hashIdentityKey)
{
throw new ArgumentException("Unexpected test type: " + testType);
}
_testType = testType;
_skipCheck = skipCheck;
ICollection <Expr> returns = new List <Expr>(thens.Values);
returns.Add(defaultExpr);
_returnType = Compiler.MaybeClrType(returns);
if (RT.count(skipCheck) > 0 && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Performance warning, {0}:{1}:{2} - hash collision of some case test constants; if selected, those entries will be tested sequentially.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(sourceSpan), Compiler.GetColumnFromSpanMap(sourceSpan));
}
}
private ConstructorInfo ComputeCtor()
{
if (Compiler.CompileStubClassVar.isBound && _type == (Type)Compiler.CompileStubClassVar.deref())
{
return(null);
}
int numArgs = _args.Count;
int numCtors;
ConstructorInfo ctor = Reflector.GetMatchingConstructor(_spanMap, _type, _args, out numCtors);
if (numCtors == 0)
{
if (_type.IsValueType && numArgs == 0)
{
// Value types have a default no-arg c-tor that is not picked up in the regular c-tors.
_isNoArgValueTypeCtor = true;
return(null);
}
throw new InvalidOperationException(string.Format("No constructor in type: {0} with {1} arguments", _type.Name, numArgs));
}
if (ctor == null && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Reflection warning, {0}:{1} - call to {2} ctor can't be resolved.",
Compiler.SourcePathVar.deref(), _spanMap != null ? (int)_spanMap.valAt(RT.StartLineKey, 0) : 0, _type.FullName);
}
return(ctor);
}
private Expression GenTestExprForInts(ObjExpr objx, GenContext context, Type exprType, LabelTarget defaultLabel)
{
if (exprType == null)
{
if (RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Performance warning, {0}:{1} - case has int tests, but tested expression is not primitive.",
Compiler.SourcePathVar.deref(), RT.get(_sourceSpan, RT.StartLineKey));
}
ParameterExpression parm = Expression.Parameter(typeof(object), "p");
Expression initParm = Expression.Assign(parm, _expr.GenCode(RHC.Expression, objx, context));
Expression testType = Expression.Call(null, Compiler.Method_Util_IsNonCharNumeric, parm); // matching JVM's handling of char as non-integer
Expression expr = GenShiftMask(Expression.Call(null, Compiler.Method_Util_ConvertToInt, parm));
return(Expression.Block(
new ParameterExpression[] { parm },
initParm,
Expression.IfThen(Expression.Not(testType), Expression.Goto(defaultLabel)),
expr));
}
else if (exprType == typeof(long) || exprType == typeof(int) || exprType == typeof(short) || exprType == typeof(byte) || exprType == typeof(ulong) || exprType == typeof(uint) || exprType == typeof(ushort) || exprType == typeof(sbyte))
{
Expression expr = Expression.Convert(_expr.GenCodeUnboxed(RHC.Expression, objx, context), typeof(int));
return(GenShiftMask(expr));
}
else
{
return(Expression.Goto(defaultLabel));
}
}
private static void MaybeReflectionWarn(IPersistentMap spanMap, MethodBase method, string methodName, IList <HostArg> args)
{
if (method == null && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine(string.Format("Reflection warning, {0}:{1} - call to {2} can't be resolved.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(spanMap), methodName));
}
}
public StaticMethodExpr(string source, IPersistentMap spanMap, Symbol tag, Type type, string methodName, IList <Type> typeArgs, IList <HostArg> args, bool tailPosition)
: base(source, spanMap, tag, methodName, typeArgs, args, tailPosition)
{
_type = type;
_method = Reflector.GetMatchingMethod(spanMap, _type, _args, _methodName, typeArgs);
if (_method != null && warnOnBoxedKeyword.Equals(RT.UncheckedMathVar.deref()) && IsBoxedMath(_method))
{
RT.errPrintWriter().WriteLine("Boxed math warning, {0}:{1}:{2} - call {3}.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(spanMap), Compiler.GetColumnFromSpanMap(spanMap), _method.ToString());
}
}
static void Main(string[] args)
{
TextWriter outTW = (TextWriter)RT.OutVar.deref();
TextWriter errTW = RT.errPrintWriter();
string path = Environment.GetEnvironmentVariable(PATH_PROP);
path = path ?? ".";
string warnVal = Environment.GetEnvironmentVariable(REFLECTION_WARNING_PROP);
bool warnOnReflection = warnVal == null ? false : warnVal.Equals("true");
string mathVal = Environment.GetEnvironmentVariable(UNCHECKED_MATH_PROP);
bool uncheckedMath = mathVal == null ? false : mathVal.Equals("true");
try
{
Var.pushThreadBindings(RT.map(
Compiler.CompilePathVar, path,
RT.WarnOnReflectionVar, warnOnReflection,
RT.UncheckedMathVar, uncheckedMath
));
Stopwatch sw = new Stopwatch();
foreach (string lib in args)
{
sw.Reset();
sw.Start();
outTW.Write("Compiling {0} to {1}", lib, path);
outTW.Flush();
Compiler.CompileVar.invoke(Symbol.intern(lib));
sw.Stop();
outTW.WriteLine(" -- {0} milliseconds.", sw.ElapsedMilliseconds);
}
}
catch (Exception e)
{
errTW.WriteLine(e.ToString());
Environment.Exit(1);
}
finally
{
Var.popThreadBindings();
try {
outTW.Flush();
}
catch (IOException e)
{
errTW.WriteLine(e.StackTrace);
}
}
}
internal InstanceZeroArityCallExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string memberName)
{
_source = source;
_spanMap = spanMap;
_memberName = memberName;
_target = target;
_tag = tag;
_targetType = target.HasClrType ? target.ClrType : null;
if (RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Reflection warning, {0}:{1}:{2} - reference to field/property {3} can't be resolved.",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(_spanMap), Compiler.GetColumnFromSpanMap(_spanMap), memberName);
}
}
private void WarnOrFailOnReplace(Symbol sym, object o, object v)
{
if (o is Var ovar)
{
Namespace ns = ovar.Namespace;
Var vv = v as Var;
if (ns == this || (vv != null && vv.ns == RT.ClojureNamespace))
{
return;
}
if (ns != RT.ClojureNamespace)
{
throw new InvalidOperationException(sym + " already refers to: " + o + " in namespace: " + _name);
}
}
RT.errPrintWriter().WriteLine("WARNING: {0} already refers to: {1} in namespace: {2}, being replaced by: {3}",
sym, o, _name, v);
}
private static void MaybeReflectionWarn(IPersistentMap spanMap, Type targetType, bool isStatic, bool hasMethods, MethodBase method, string methodName, IList <HostArg> args)
{
if (method == null && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
if (targetType == null)
{
RT.errPrintWriter().WriteLine(string.Format("Reflection warning, {0}:{1}:{2} - call to method {4} can't be resolved (target class is unknown).",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(spanMap), Compiler.GetColumnFromSpanMap(spanMap), (isStatic ? "static " : ""), methodName));
}
else if (hasMethods)
{
RT.errPrintWriter().WriteLine(string.Format("Reflection warning, {0}:{1}:{2} - call to {3}method {4} on {5} can't be resolved (argument types: {6}).",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(spanMap), Compiler.GetColumnFromSpanMap(spanMap), (isStatic ? "static " : ""), methodName, targetType.FullName, GetTypeStringForArgs(args)));
}
else
{
RT.errPrintWriter().WriteLine(string.Format("Reflection warning, {0}:{1}:{2} - call to {3}method {4} on {5} can't be resolved (no such method).",
Compiler.SourcePathVar.deref(), Compiler.GetLineFromSpanMap(spanMap), Compiler.GetColumnFromSpanMap(spanMap), (isStatic ? "static " : ""), methodName, targetType.FullName, GetTypeStringForArgs(args)));
}
}
}
static void Main(string[] args)
{
TextWriter outTW = (TextWriter)RT.OutVar.deref();
TextWriter errTW = RT.errPrintWriter();
string path = Environment.GetEnvironmentVariable(PATH_PROP);
// TODO: get rid of this when we have the full build process set up
path = path ?? ".";
if (path == null)
{
errTW.WriteLine("ERROR: Must set system property {0}", PATH_PROP);
errTW.WriteLine("to the location for the compiled .class files.");
errTW.WriteLine("This directory must also be on your {0}.", RT.ClojureLoadPathString);
Environment.Exit(1);
}
string warnVal = Environment.GetEnvironmentVariable(REFLECTION_WARNING_PROP);
bool warnOnReflection = warnVal == null ? false : warnVal.Equals(true);
string mathVal = Environment.GetEnvironmentVariable(UNCHECKED_MATH_PROP);
bool uncheckedMath = mathVal == null ? false : mathVal.Equals(true);
try
{
Var.pushThreadBindings(RT.map(
Compiler.CompilePathVar, path,
RT.WarnOnReflectionVar, warnOnReflection,
RT.UncheckedMathVar, uncheckedMath
));
Stopwatch sw = new Stopwatch();
foreach (string lib in args)
{
sw.Reset();
sw.Start();
outTW.Write("Compiling {0} to {1}", lib, path);
outTW.Flush();
Compiler.CompileVar.invoke(Symbol.intern(lib));
sw.Stop();
outTW.WriteLine(" -- {0} milliseconds.", sw.ElapsedMilliseconds);
}
}
catch (Exception e)
{
errTW.WriteLine(e.ToString());
Environment.Exit(1);
}
finally
{
Var.popThreadBindings();
try {
outTW.Flush();
outTW.Close();
}
catch (IOException e)
{
errTW.WriteLine(e.StackTrace);
}
}
}
public Expr Parse(ParserContext pcon, object frm)
{
string source = (string)Compiler.SourceVar.deref();
IPersistentMap spanMap = (IPersistentMap)Compiler.SourceSpanVar.deref(); // Compiler.GetSourceSpanMap(form);
ISeq form = (ISeq)frm;
IPersistentVector loopLocals = (IPersistentVector)Compiler.LoopLocalsVar.deref();
if (pcon.Rhc != RHC.Return || loopLocals == null)
{
throw new ParseException("Can only recur from tail position");
}
if (Compiler.NoRecurVar.deref() != null)
{
throw new ParseException("Cannot recur across try");
}
IPersistentVector args = PersistentVector.EMPTY;
for (ISeq s = RT.seq(form.next()); s != null; s = s.next())
{
args = args.cons(Compiler.Analyze(pcon.SetRhc(RHC.Expression).SetAssign(false), s.first()));
}
if (args.count() != loopLocals.count())
{
throw new ParseException(string.Format("Mismatched argument count to recur, expected: {0} args, got {1}",
loopLocals.count(), args.count()));
}
for (int i = 0; i < loopLocals.count(); i++)
{
LocalBinding lb = (LocalBinding)loopLocals.nth(i);
Type primt = lb.PrimitiveType;
if (primt != null)
{
bool mismatch = false;
Type pt = Compiler.MaybePrimitiveType((Expr)args.nth(i));
if (primt == typeof(long))
{
if (!(pt == typeof(long) || pt == typeof(int) || pt == typeof(short) || pt == typeof(uint) || pt == typeof(ushort) || pt == typeof(ulong) ||
pt == typeof(char) || pt == typeof(byte) || pt == typeof(sbyte)))
{
mismatch = true;
}
}
else if (primt == typeof(double))
{
if (!(pt == typeof(double) || pt == typeof(float)))
{
mismatch = true;
}
}
if (mismatch)
{
lb.RecurMismatch = true;
if (RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("{0}:{1} recur arg for primitive local: {2} is not matching primitive, had: {3}, needed {4}",
source, spanMap != null ? (int)spanMap.valAt(RT.StartLineKey, 0) : 0,
lb.Name, pt != null ? pt.Name : "Object", primt.Name);
}
}
}
}
return(new RecurExpr(source, spanMap, loopLocals, 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));
}
public Expr Parse(ParserContext pcon, object frm)
{
ISeq form = (ISeq)frm;
// form => (let [var1 val1 var2 val2 ... ] body ... )
// or (loop [var1 val1 var2 val2 ... ] body ... )
bool isLoop = RT.first(form).Equals(Compiler.LoopSym);
if (!(RT.second(form) is IPersistentVector bindings))
{
throw new ParseException("Bad binding form, expected vector");
}
if ((bindings.count() % 2) != 0)
{
throw new ParseException("Bad binding form, expected matched symbol/value pairs.");
}
ISeq body = RT.next(RT.next(form));
if (pcon.Rhc == RHC.Eval ||
(pcon.Rhc == RHC.Expression && isLoop))
{
return(Compiler.Analyze(pcon, RT.list(RT.list(Compiler.FnOnceSym, PersistentVector.EMPTY, form)), "let__" + RT.nextID()));
}
ObjMethod method = (ObjMethod)Compiler.MethodVar.deref();
IPersistentMap backupMethodLocals = method.Locals;
IPersistentMap backupMethodIndexLocals = method.IndexLocals;
IPersistentVector recurMismatches = PersistentVector.EMPTY;
for (int i = 0; i < bindings.count() / 2; i++)
{
recurMismatches = recurMismatches.cons(false);
}
// may repeat once for each binding with a mismatch, return breaks
while (true)
{
IPersistentMap dynamicBindings = RT.map(
Compiler.LocalEnvVar, Compiler.LocalEnvVar.deref(),
Compiler.NextLocalNumVar, Compiler.NextLocalNumVar.deref());
method.SetLocals(backupMethodLocals, backupMethodIndexLocals);
if (isLoop)
{
dynamicBindings = dynamicBindings.assoc(Compiler.LoopLocalsVar, null);
}
try
{
Var.pushThreadBindings(dynamicBindings);
IPersistentVector bindingInits = PersistentVector.EMPTY;
IPersistentVector loopLocals = PersistentVector.EMPTY;
for (int i = 0; i < bindings.count(); i += 2)
{
if (!(bindings.nth(i) is Symbol))
{
throw new ParseException("Bad binding form, expected symbol, got " + bindings.nth(i));
}
Symbol sym = (Symbol)bindings.nth(i);
if (sym.Namespace != null)
{
throw new ParseException("Can't let qualified name: " + sym);
}
Expr init = Compiler.Analyze(pcon.SetRhc(RHC.Expression).SetAssign(false), bindings.nth(i + 1), sym.Name);
if (isLoop)
{
if (recurMismatches != null && RT.booleanCast(recurMismatches.nth(i / 2)))
{
HostArg ha = new HostArg(HostArg.ParameterType.Standard, init, null);
List <HostArg> has = new List <HostArg>(1)
{
ha
};
init = new StaticMethodExpr("", PersistentArrayMap.EMPTY, null, typeof(RT), "box", null, has, false);
if (RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Auto-boxing loop arg: " + sym);
}
}
else if (Compiler.MaybePrimitiveType(init) == typeof(int))
{
List <HostArg> args = new List <HostArg>
{
new HostArg(HostArg.ParameterType.Standard, init, null)
};
init = new StaticMethodExpr("", null, null, typeof(RT), "longCast", null, args, false);
}
else if (Compiler.MaybePrimitiveType(init) == typeof(float))
{
List <HostArg> args = new List <HostArg>
{
new HostArg(HostArg.ParameterType.Standard, init, null)
};
init = new StaticMethodExpr("", null, null, typeof(RT), "doubleCast", null, args, false);
}
}
// Sequential enhancement of env (like Lisp let*)
LocalBinding b = Compiler.RegisterLocal(sym, Compiler.TagOf(sym), init, typeof(Object), false);
BindingInit bi = new BindingInit(b, init);
bindingInits = bindingInits.cons(bi);
if (isLoop)
{
loopLocals = loopLocals.cons(b);
}
}
if (isLoop)
{
Compiler.LoopLocalsVar.set(loopLocals);
}
Expr bodyExpr;
bool moreMismatches = false;
try
{
if (isLoop)
{
object methodReturnContext = pcon.Rhc == RHC.Return ? Compiler.MethodReturnContextVar.deref() : null;
// stuff with clear paths,
Var.pushThreadBindings(RT.map(Compiler.NoRecurVar, null,
Compiler.MethodReturnContextVar, methodReturnContext));
}
bodyExpr = new BodyExpr.Parser().Parse(isLoop ? pcon.SetRhc(RHC.Return) : pcon, body);
}
finally
{
if (isLoop)
{
Var.popThreadBindings();
for (int i = 0; i < loopLocals.count(); i++)
{
LocalBinding lb = (LocalBinding)loopLocals.nth(i);
if (lb.RecurMismatch)
{
recurMismatches = (IPersistentVector)recurMismatches.assoc(i, true);
moreMismatches = true;
}
}
}
}
if (!moreMismatches)
{
return(new LetExpr(bindingInits, bodyExpr, isLoop));
}
}
finally
{
Var.popThreadBindings();
}
}
}
static void Main(string[] args)
{
TextWriter outTW = (TextWriter)RT.OutVar.deref();
TextWriter errTW = RT.errPrintWriter();
string path = Environment.GetEnvironmentVariable(PATH_PROP);
path = path ?? ".";
string warnVal = Environment.GetEnvironmentVariable(REFLECTION_WARNING_PROP);
bool warnOnReflection = warnVal == null ? false : warnVal.Equals("true");
string mathVal = Environment.GetEnvironmentVariable(UNCHECKED_MATH_PROP);
bool uncheckedMath = mathVal == null ? false : mathVal.Equals("true");
object compilerOptions = null;
foreach (DictionaryEntry kv in Environment.GetEnvironmentVariables())
{
String name = (String)kv.Key;
String v = (String)kv.Value;
if (name.StartsWith("CLOJURE_COMPILER_"))
{
compilerOptions = RT.assoc(compilerOptions
, RT.keyword(null, name.Substring(1 + name.LastIndexOf('_')))
, RT.readString(v));
}
}
try
{
Var.pushThreadBindings(RT.map(
Compiler.CompilePathVar, path,
RT.WarnOnReflectionVar, warnOnReflection,
RT.UncheckedMathVar, uncheckedMath,
Compiler.CompilerOptionsVar, compilerOptions
));
Stopwatch sw = new Stopwatch();
foreach (string lib in args)
{
sw.Reset();
sw.Start();
outTW.Write("Compiling {0} to {1}", lib, path);
outTW.Flush();
Compiler.CompileVar.invoke(Symbol.intern(lib));
sw.Stop();
outTW.WriteLine(" -- {0} milliseconds.", sw.ElapsedMilliseconds);
}
}
catch (Exception e)
{
errTW.WriteLine(e.ToString());
Environment.Exit(1);
}
finally
{
Var.popThreadBindings();
try {
outTW.Flush();
outTW.Close();
}
catch (IOException e)
{
errTW.WriteLine(e.StackTrace);
}
}
}
