internal Object Load(LocTextReader t)
{
Object expr = null;
do
{
Int32 line = t.line;
expr = Read(t);
if (!Eof(expr))
{
try
{
eval(expr, globalenv);
}
catch (Exception ex)
{
Loc loc = new Loc(t.file, line);
Console.Error.WriteLine(ex);
Console.Error.WriteLine("loc=" + loc);
Console.ReadLine();
throw BacktraceException.push(ex,
new BacktraceFrame(loc, "when evaluating ", expr), this);
}
}
}while(!Eof(expr));
return(true);
}
public Object eval(Env env)
{
DynamicEnv olddenv = DynamicEnv.current();
try
{
for (int i = 0; i < binds.Length; i++)
{
DynamicEnv.extend(binds[i].dvar.sym,
binds[i].expr.eval(env));
}
return(body.eval(env));
}
catch (BacktraceException bex)
{
throw bex;
}
catch (Exception ex)
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, "set", null), interpreter);
}
finally
{
DynamicEnv.restore(olddenv);
}
}
public Object Invoke(params Object[] args)
{
try
{
return(body.eval(
new Env(argSpecs.parameters, buildParamArray(args, 0, env), env)));
}
catch (Exception ex)
{
if (!(ex is BacktraceException))
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, this, args), interpreter);
}
throw ex;
}
}
public Object eval(Env env)
{
try
{
Object retval = val.eval(env);
var.setval(retval, env);
return(retval);
}
catch (BacktraceException bex)
{
throw bex;
}
catch (Exception ex)
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, "set", null), interpreter);
}
}
public Object eval(Env env)
{
try
{
if (Util.isTrue(test.eval(env)))
{
return(brtrue.eval(env));
}
return(brfalse.eval(env));
}
catch (BacktraceException bex)
{
throw bex;
}
catch (Exception ex)
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, "if", null), interpreter);
}
}
public Object eval(Env env)
{
try
{
for (Int32 i = 0; i < exprs.Length - 1; i++)
{
exprs[i].eval(env);
}
return(exprs[exprs.Length - 1].eval(env));
}
catch (BacktraceException bex)
{
throw bex;
}
catch (Exception ex)
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, "set", null), interpreter);
}
}
public Object eval(Env env)
{
try
{
while (Util.isTrue(test.eval(env)))
{
body.eval(env);
}
return(null);
}
catch (BacktraceException bex)
{
throw bex;
}
catch (Exception ex)
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, "set", null), interpreter);
}
}
public Object eval(Env env)
{
Object f = fexpr.eval(env);
Object[] args = new Object[argexprs.Length];
for (Int32 i = 0; i < args.Length; i++)
{
args[i] = argexprs[i].eval(env);
}
Boolean doTrace = fsym != null &&
interpreter.traceList.Contains(fsym);
try
{
if (doTrace)
{
interpreter.trace(fsym.name, args);
Trace.Indent();
Object ret = Util.InvokeObject(f, args);
Trace.Unindent();
return(ret);
}
else
{
return(Util.InvokeObject(f, args));
}
}
catch (Exception ex)
{
if (fsym != null && !fsym.name.Equals("throw"))
{
throw BacktraceException.push(ex, new BacktraceFrame(loc, fsym, args)
, interpreter);
}
else
{
throw ex;
}
}
}
internal Object Load(LocTextReader t)
{
Object expr = null;
do
{
Int32 line = t.line;
expr = Read(t);
if (!Eof(expr))
{
try
{
eval(expr, globalenv);
}
catch (Exception ex)
{
throw BacktraceException.push(ex,
new BacktraceFrame(new Loc(t.file, line), "when evaluating ", expr), this);
}
}
}while(!Eof(expr));
return(true);
}
internal IExpression analyze(Object expr, Env env, Loc enclosingLoc)
{
Symbol symbol = expr as Symbol;
if (symbol != null)
{
if (symbol.isDynamic)
{
return(new DynamicVar(symbol));
}
Object var = env.lookup(symbol);
if (var is LocalVariable)
{
return(new LocalVar((LocalVariable)var));
}
else
{
return(new GlobalVar((Symbol)var));
}
}
if (!(expr is Cons)) //must be literal
{
return(new QuoteExpr(expr));
}
Cons exprs = (Cons)expr;
Loc loc = (Loc)reader.locTable[expr];
if (loc != null)
{
reader.locTable.Remove(expr);
}
else
{
loc = enclosingLoc;
}
Object f = exprs.first;
Cons args = exprs.rest;
//see if it's a macro
Symbol s = f as Symbol;
if (s != null && s.isDefined() && s.getGlobalValue() is Macro)
{
Macro m = (Macro)s.getGlobalValue();
Object[] argarray = Cons.ToVector(args);
Object mexprs = null;
try
{
mexprs = m.Invoke(argarray);
}
catch (Exception ex)
{
BacktraceFrame frame = new BacktraceFrame(loc, s, args);
throw BacktraceException.push(ex, frame, this);
}
try
{
return(analyze(mexprs, env, loc));
}
catch (Exception ex)
{
BacktraceFrame frame = new BacktraceFrame(loc, "when expanding ", exprs);
throw BacktraceException.push(ex, frame, this);
}
}
Int32 numargs = Cons.Length(args);
if (f == DLET)
{
return(new DynamicLet(args, env, this, loc));
}
else if (f == FN)
{
return(new Closure(args, env, this, loc));
}
else if (f == MACRO)
{
return(new Macro(args, env, this, loc));
}
else if (f == WHILE)
{
return(new WhileExpression(args, env, this, loc));
}
else if (f == BLOCK)
{
if (numargs == 0)
{
return(new QuoteExpr(null));
}
//remove block from block of one
else if (numargs == 1)
{
return(analyze(args.first, env, loc));
}
else
{
return(new BlockExpression(args, env, this, loc));
}
}
else if (f == OR)
{
if (numargs == 0)
{
return(new QuoteExpr(null));
}
else
{
return(new OrExpression(args, env, this, loc));
}
}
else if (f == IF)
{
return(new IfExpression(args, env, this, loc));
}
else if (f == QUOTE)
{
return(new QuoteExpr(args.first));
}
else if (f == SET)
{
return(new SetExpression(args, env, this, loc));
}
else //presume funcall
{
return(new ApplyExpression(exprs, env, this, loc));
}
}
