protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
var binding = thread.Bind(FunctionName, BindingRequestFlags.Read);
var result = binding.GetValueRef(thread);
if (result == null)
{
thread.ThrowScriptError("Unknown identifier: {0}", FunctionName);
return null;
}
CallTarget = result as ICallTarget;
if (CallTarget == null)
{
thread.ThrowScriptError("This identifier cannot be called: {0}", FunctionName);
return null;
}
// set Evaluate pointer
Evaluate = DoCall;
// standard epilog is done by DoCall
return DoCall(thread);
}
protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
if (EntryPoint == null)
{
thread.ThrowScriptError("No entry point defined (entry point is a function named «Go»)");
return null;
}
// define built-in runtime library functions
var libraryFunctions = LibraryFunction.ExtractLibraryFunctions(thread, new RefalLibrary(thread));
foreach (var libFun in libraryFunctions)
{
var binding = thread.Bind(libFun.Name, BindingRequestFlags.Write | BindingRequestFlags.ExistingOrNew);
binding.SetValueRef(thread, libFun);
}
// define functions declared in the compiled program
foreach (var fun in FunctionList)
{
fun.Evaluate(thread);
}
// call entry point with an empty expression
EntryPoint.Call(thread, new object[] { PassiveExpression.Build() });
// standard epilog
thread.CurrentNode = Parent;
return null;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var iCall = FunctionFactory.BindFunction(_targetName);
if (iCall == null)
thread.ThrowScriptError("Not callable", _targetName);
var args = (object[])_arguments.Evaluate(thread);
object result = iCall.Call(thread, args);
thread.CurrentNode = Parent; //standard epilog
return result;
}
// Evaluation for non-tail languages
private object EvaluateNoTail(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var target = TargetRef.Evaluate(thread);
var iCall = target as ICallTarget;
if (iCall == null)
thread.ThrowScriptError(Resources.ErrVarIsNotCallable, _targetName);
var args = (object[])Arguments.Evaluate(thread);
object result = iCall.Call(thread, args);
thread.CurrentNode = Parent; //standard epilog
return result;
}
protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
foreach (var sentence in Sentences)
{
sentence.InputExpression = InputExpression;
sentence.BlockPattern = BlockPattern;
var result = sentence.Evaluate(thread);
if (result != null)
{
// standard epilog
thread.CurrentNode = Parent;
return result;
}
}
// standard Refal exception: input expression doesn't match any pattern
thread.ThrowScriptError("Recognition impossible");
return null;
}
protected override object DoEvaluate(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
thread.ThrowScriptError(Resources.ErrConstructNotSupported, Name);
return null; //never happens
}
public override object Call(ScriptThread thread, object[] parameters)
{
thread.ThrowScriptError("Calling external function is not supported");
return null;
}
protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
object result = null;
// is this variable a part of a pattern?
if (UseType == NodeUseType.Name)
{
// don't evaluate it
result = CreateVariable();
}
else
{
// get last recognized pattern
var pattern = thread.GetLastPattern();
if (pattern == null)
{
thread.ThrowScriptError("No pattern recognized!");
return null;
}
// read variable from the last recognized pattern
result = pattern.GetVariable(Index);
}
// standard epilog
thread.CurrentNode = Parent;
return result;
}
private object EvaluateWithTailCheck(ScriptThread thread)
{
thread.CurrentNode = this; //standard prolog
var target = TargetRef.Evaluate(thread);
var iCall = target as ICallTarget;
if (iCall == null)
thread.ThrowScriptError(Resources.ErrVarIsNotCallable, _targetName);
var args = (object[])Arguments.Evaluate(thread);
object result = null;
result = iCall.Call(thread, args);
//Note that after invoking tail we can get another tail.
// So we need to keep calling tails while they are there.
while (thread.Tail != null) {
var tail = thread.Tail;
var tailArgs = thread.TailArgs;
thread.Tail = null;
thread.TailArgs = null;
result = tail.Call(thread, tailArgs);
}
thread.CurrentNode = Parent; //standard epilog
return result;
}
protected override object DoEvaluate(ScriptThread thread) {
thread.CurrentNode = this; //standard prolog
thread.ThrowScriptError(Resources.ErrNullNodeEval, this.Term);
return null; //never happens
}
protected override object DoEvaluate(ScriptThread thread)
{
// standard prolog
thread.CurrentNode = this;
// evaluate expression
var expression = Expression.EvaluateExpression(thread);
object result = null;
// extract last recognized pattern (it contains bound variables)
var lastPattern = thread.GetLastPattern();
if (lastPattern == null)
{
thread.ThrowScriptError("Internal error: last recognized pattern is lost.");
return null; // never gets here
}
// with-clause
if (Block != null)
{
Block.InputExpression = expression;
Block.BlockPattern = lastPattern;
result = Block.Evaluate(thread);
}
// where-clause
else if (Pattern != null)
{
result = EvaluateWhereClause(expression, lastPattern, thread);
}
// internal compiler error
else
{
thread.ThrowScriptError("Internal error: AST node doen't represent neither where- nor when-clause.");
return null; // never get here
}
// standard epilog
thread.CurrentNode = Parent;
return result;
}