public void Run(string coreCodePath, string filePath = null)
{
try
{
LoadAndExecute(coreCodePath);
}
catch (Exception e)
{
if (!(e is InterpreterException))
{
throw new InterpreterException("Cannot load core library", e);
}
throw;
}
Func <object> func = () =>
{
if (filePath != null)
{
LoadAndExecute(filePath);
}
return(null);
};
InterpreterHelper.ActAndHandleException(func);
}
public override object Walk(ConditionalExpression node)
{
var cond = node.Condition.Accept(this);
return(InterpreterHelper.IsTrue(cond)
? node.TrueExpression.Accept(this)
: node.FalseExpression.Accept(this));
}
public override object Walk(IfStatement node)
{
var cond = node.Condition.Accept(this);
if (InterpreterHelper.IsTrue(cond))
{
return(node.Body.Accept(this));
}
return(node.Else != null?node.Else.Accept(this) : null);
}
public override object Walk(WhileStatement node)
{
object result = null;
while (InterpreterHelper.IsTrue(node.Condition.Accept(this)))
{
try
{
result = node.Body.Accept(this);
}
catch (Break)
{
break;
}
catch (Next)
{
continue;
}
}
return(result);
}
public object Callback(object[] args)
{
bool newThread = false;
if (callingThread != Thread.CurrentThread)
{
newThread = true;
var callingInstance = ContextLocal[callingThread];
new InterpretationContext(callingInstance);
ContextLocal.ClearCollected();
}
Func <object> func = () =>
{
var interpreter = InterpretationContext.Instance.Interpreter;
var result = interpreter.CallBikeFunction(Function,
Target,
interpreter.
MarshallArgumentsToBike(
args));
if (ReturnType == typeof(void))
{
return(null);
}
result = interpreter.MarshallToClr(result);
object adjustedResult = result;
if (TryConvert(ReturnType, Target, ref adjustedResult))
{
return(adjustedResult);
}
throw ErrorFactory.CreateClrError(string.Format(
"Invalid return type: expect {0}, actual {1}",
ReturnType, result));
};
return(newThread ? InterpreterHelper.ActAndHandleException(func, true) : func());
}
public BikeBoolean OpNot(object value)
{
return(new BikeBoolean(!InterpreterHelper.IsTrue(value)));
}
public object OpOr(object lv, Func <object> rvThunk)
{
return(InterpreterHelper.IsTrue(lv) ? lv : rvThunk());
}
public object OpAnd(object lv, Func <object> rvThunk)
{
return(InterpreterHelper.IsTrue(lv) ? rvThunk() : lv);
}