public override TResult Call <TResult>(ICallable <TResult> callable)
{
lock (Mutex)
{
return(callable.Call());
}
}
public object VisitCallExpression(CallExpression expression)
{
object callee = Evaluate(expression.callee);
List <object> arguments = new List <object>();
foreach (IExpression argument in expression.arguments)
{
arguments.Add(Evaluate(argument));
}
// Incorrect call, the calle cannot be called (ie. "some string"() )
if (callee is ICallable == false)
{
throw new RuntimeError(expression.paren, "Can only call functions and classes.");
}
ICallable function = (ICallable)callee;
// Not correct number of arguments
if (arguments.Count != function.Arity())
{
// TODO: Might want to make it like JavaScript where it uses null when not enough, and discards when too many
throw new RuntimeError(expression.paren, $"Expected {function.Arity()} arguments but got {arguments.Count}.");
}
return(function.Call(this, expression, arguments));
}
public object VisitCallExpr(Expr.Call expr)
{
object callee = Evaluate(expr.Callee);
List <object> arguments = new List <object>();
foreach (var argument in expr.Arguments)
{
arguments.Add(Evaluate(argument));
}
if (!(callee is ICallable))
{
throw new InterpretingException(expr.Paren,
"Can only call functions and classes.");
}
ICallable function = (ICallable)callee;
if (arguments.Count != function.Arity)
{
throw new InterpretingException(expr.Paren,
$"Expected {function.Arity} arguments but got {arguments.Count}.");
}
return(function.Call(this, arguments));
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void OnDisable()
{
if (null != _onDisable)
{
_onDisable.Call(_this, null);
}
}
private void BlockTag(string tag, IDictionary attributes, ICallable block)
{
Output.Write("<{0}", tag);
var attributeValues = new System.Collections.Generic.List <string>();
if (null != attributes)
{
foreach (DictionaryEntry entry in attributes)
{
attributeValues.Add(string.Format("{0}=\"{1}\"", entry.Key, entry.Value));
}
}
if (0 != attributeValues.Count)
{
Output.Write(" ");
Output.Write(string.Join(" ", attributeValues.ToArray()));
}
Output.Write(">");
if (block != null)
{
block.Call(null);
}
Output.Write("</{0}>", tag);
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void OnDestroy()
{
if (null != _onDestroy)
{
_onDestroy.Call(_this, null);
}
}
//call an ICallable object directly
public static object Run(Environment env, ICallable callable, List <object> arguments)
{
try {
//build the call object
Token token = new Token(TokenType.EOF, "internal", null, -1);
//build a new interpreter
Interpreter interpreter = new Interpreter(env);
Resolver resolver = new Resolver(interpreter);
resolver.Resolve(((ScriptFunction)callable).GetDeclaration());
//call the ICallable, returning the result
return(callable.Call(interpreter, token, arguments));
//WARNING: duplicate code
} catch (ErrorHandler.AssertError) {
ConsoleOutput.Log("Assert error caught at Run()");
ConsoleOutput.Log("The program will now exit early");
} catch (ErrorHandler.ParserError e) {
ConsoleOutput.Log("Parser error caught at Run()");
ConsoleOutput.Log("The following output is for internal debugging only, and will be removed from the final release:\n" + e.ToString());
} catch (ErrorHandler.ResolverError e) {
ConsoleOutput.Log("Resolver error caught at Run()");
ConsoleOutput.Log("The following output is for internal debugging only, and will be removed from the final release:\n" + e.ToString());
} catch (ErrorHandler.RuntimeError e) {
ConsoleOutput.Log("Runtime error caught at Run()");
ConsoleOutput.Log("The following output is for internal debugging only, and will be removed from the final release:\n" + e.ToString());
} catch (Exception e) {
ConsoleOutput.Log("Terminal error caught at Run()");
ConsoleOutput.Log("The following output is for internal debugging only, and will be removed from the final release:\n" + e.ToString());
}
return(null);
}
/// <summary>
/// Evaluate a function call expression
/// </summary>
/// <param name="expr"></param>
/// <returns></returns>
public object VisitFunctionCallExpr(FunctionCall expr)
{
// get the called function
object callee = Evaluate(expr.Callee);
// evaluate the passed arguments
List <object> arguments = new List <object>();
foreach (Expr argument in expr.Arguments)
{
arguments.Add(Evaluate(argument));
}
if (!(callee is ICallable))
{
throw new RuntimeError(expr.Keyword, "Only functions are callable");
}
ICallable function = (ICallable)callee;
// if the passed arguments are less than or exceep function argument length
if (arguments.Count != function.ArgumentLength)
{
throw new RuntimeError(expr.Keyword, $"Expected {function.ArgumentLength} arguments but got {arguments.Count}");
}
// call the function
return(function.Call(this, arguments));
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void Awake()
{
try
{
_host.Execute(Script.String());
}
catch (Exception exception)
{
Debug.LogWarning("Could not execute script: " + exception.Message);
return;
}
_this = JsValue.FromObject(_host, this);
_update = _host.GetFunction("Update");
_fixedUpdate = _host.GetFunction("FixedUpdate");
_lateUpdate = _host.GetFunction("LateUpdate");
_awake = _host.GetFunction("Awake");
_start = _host.GetFunction("Start");
_onEnable = _host.GetFunction("OnEnable");
_onDisable = _host.GetFunction("OnDisable");
_onDestroy = _host.GetFunction("OnDestroy");
if (null != _awake)
{
_awake.Call(_this, null);
}
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void Update()
{
if (null != _update)
{
_update.Call(_this, null);
}
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void FixedUpdate()
{
if (null != _fixedUpdate)
{
_fixedUpdate.Call(_this, null);
}
}
object Expr.IVisitor <object> .Visit(Expr.Call _call)
{
object callee = Evaluate(_call.callee);
List <object> arguments = new List <object>();
foreach (Expr argument in _call.arguments)
{
arguments.Add(Evaluate(argument));
}
if (!(callee is ICallable))
{
throw new RuntimeError(_call.paren, "Can only call functions and classes.");
}
ICallable function = (ICallable)callee;
if (arguments.Count != function.Arity)
{
throw new RuntimeError(_call.paren, "Expected " + function.Arity + " arguments, but got " + arguments.Count + ".");
}
return(function.Call(this, arguments));
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void Start()
{
if (null != _start)
{
_start.Call(_this, null);
}
}
public object VisitCallExpr(Expr.Call expr)
{
object callee = Evaluate(expr.callee);
List <object> arguments = new List <object>();
foreach (Expr argument in expr.arguments)
{
arguments.Add(Evaluate(argument));
}
if (!(callee is ICallable))
{
throw new RuntimeError(expr.paren,
"Can only call functions and classes.");
}
ICallable function = (ICallable)callee;
if (arguments.Count != function.Arity())
{
throw new RuntimeError(expr.paren, "Expected " +
function.Arity() + " arguments but got " +
arguments.Count + ".");
}
return(function.Call(this, arguments));
}
public static object GroupBy(object proc, object list)
{
ICallable p = RequiresNotNull <ICallable>(proc);
Cons e = Requires <Runtime.Cons>(list);
Hashtable result = new Hashtable();
while (e != null)
{
object key = p.Call(e.car);
object c = result[key];
result[key] = new Cons(e.car, c);
e = e.cdr as Cons;
}
Hashtable final = new Hashtable(result.Count);
//now reverse the values
foreach (DictionaryEntry de in result)
{
final[de.Key] = Reverse(de.Value);
}
return(final);
}
public static object Partition(object proc, object list)
{
ICallable p = RequiresNotNull <ICallable>(proc);
Cons e = Requires <Runtime.Cons>(list);
Cons h = null, head = null;
Cons h2 = null, head2 = null;
while (e != null)
{
if (IsTrue(p.Call(e.car)))
{
if (h == null)
{
h = head = new Cons(e.car);
}
else
{
h = (Cons)(h.cdr = new Cons(e.car));
}
}
else
{
if (h2 == null)
{
h2 = head2 = new Cons(e.car);
}
else
{
h2 = (Cons)(h2.cdr = new Cons(e.car));
}
}
e = e.cdr as Cons;
}
return(Values(head, head2));
}
public object Visit(Call expr)
{
object callee = Evaluate(expr.callee);
List <object> arguments = new List <object>();
foreach (Expr argument in expr.arguments)
{
arguments.Add(Evaluate(argument));
}
if (!(callee is ICallable))
{
throw new ErrorHandler.RuntimeError(expr.paren, "Can't call this datatype: " + (callee == null ? "null" : callee.ToString()));
}
ICallable called = (ICallable)callee;
if (arguments.Count != called.Arity())
{
throw new ErrorHandler.RuntimeError(expr.paren, "Expected " + called.Arity() + " arguments but received " + arguments.Count);
}
return(called.Call(this, expr.paren, arguments));
}
private void BlockTag(string tag, IDictionary attributes, ICallable block)
{
Output.Write("<{0}", tag);
System.Collections.Generic.List<string> attributeValues = new System.Collections.Generic.List<string>();
if (null != attributes)
{
foreach(DictionaryEntry entry in attributes)
{
attributeValues.Add(string.Format("{0}=\"{1}\"", entry.Key, entry.Value));
}
}
if (0 != attributeValues.Count)
{
Output.Write(" ");
Output.Write(string.Join(" ", attributeValues.ToArray()));
}
Output.Write(">");
if (block != null)
{
block.Call(null);
}
Output.Write("</{0}>", tag);
}
public object VisitCallExpr(Call expr)
{
Object callee = Evaluate(expr.Callee);
List <Object> arguments = new List <Object>();
foreach (Expr argument in expr.Arguments)
{
arguments.Add(Evaluate(argument));
}
if (!(callee is ICallable))
{
// TODO: Change error message to not mention classes explicitly
// since this shows up before classes are implemented.
throw new RuntimeError(expr.Paren, "Can only call functions and classes.");
}
ICallable function = (ICallable)callee;
if (arguments.Count < function.RequiredArguments())
{
throw new RuntimeError(expr.Paren, "Not enough arguments.");
}
return(function.Call(this, arguments));
}
/// <summary>
/// Called by Unity.
/// </summary>
protected virtual void LateUpdate()
{
if (null != _lateUpdate)
{
_lateUpdate.Call(_this, null);
}
}
public int Call(ICallable callable, double salience, object value, IContinuation succ, IFailure fail)
{
if (callable is IAgent)
((IAgent)callable).Initialize(this, salience);
if (salience > 0)
return callable.Call(value, succ, fail);
return 1;
}
/// <summary>
/// Submits the specified callable to the thread pool.
/// </summary>
/// <param name="callable">The callable.</param>
/// <returns></returns>
public Future <T> Submit <T>(ICallable <T> callable)
{
var future = new SimpleFutureImpl <T>();
_taskQueue.Push(
() => future.Value = callable.Call());
return(future);
}
/// <summary>
/// Call click callback, if there is one.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BalloonTipClicked(object sender, EventArgs e)
{
if (trayCallback != null)
{
trayCallback.Call();
trayCallback = null;
}
}
public static void eachInterface(ICallable callable, IEnumerable enumerable)
{
object[] args = new object[1];
foreach (object item in enumerable)
{
args[0] = item;
callable.Call(args);
}
}
/// <summary>
/// Submits the specified callable to the thread pool.
/// </summary>
/// <param name="callable">The callable.</param>
/// <returns></returns>
public IFuture <T> Submit <T>(ICallable <T> callable)
{
var future = new FutureImpl <T>();
Log.Debug("Submit: Instance {0} - enqueuing callable", _id);
_taskQueue.Push(
() => future.Value = callable.Call());
return(future);
}
public bool MoveNext()
{
if (_enumerator.MoveNext())
{
_arguments[0] = _enumerator.Current;
_current = _function.Call(_arguments);
return(true);
}
return(false);
}
[Test] public void InvokeAnyCopiesContextWhenNewTaskForCallableWasOverriden([Values(true, false)] bool isTimed)
{
var cc = SetupContextCarrier();
var runnableFuture = MockRepository.GenerateMock <IRunnableFuture <T> >();
_callable.Stub(x => x.Call()).Return(TestData <T> .Four);
_sut.Stub(x => x.NewTaskFor(Arg <ICallable <T> > .Is.NotNull)).Return(runnableFuture);
runnableFuture.Stub(x => x.Run()).Do(new Action(() => _callable.Call()));
if (isTimed)
{
_sut.InvokeAny(Delays.Small, _callable, _callable);
}
else
{
_sut.InvokeAny(_callable, _callable);
}
runnableFuture.AssertWasCalled(x => x.Run());
Mockery.Assert(cc.ActivityOf(x => x.Restore()).First < _callable.ActivityOf(x => x.Call()).First);
}
private static void CallPhoneNumbers(ICallable phone, string[] phoneNumbers)
{
StringBuilder result = new StringBuilder();
foreach (var phoneNumber in phoneNumbers)
{
result.AppendLine(phone.Call(phoneNumber));
}
Console.Write(result);
}
public virtual void Run()
{
try
{
enclosingInstance.Value = function.Call();
}
catch (System.Exception ex)
{
enclosingInstance.Exception = ex;
}
}
static object GetValue(ICallable <object> callable)
{
try
{
return(callable.Call());
}
catch (Exception exception)
{
return(ThrowHelper.FromInvalidOperationException_Cqrs(callable, exception));
}
}
public void RenderBody(TextWriter writer)
{
if (body == null)
{
throw new MonoRailException("This component does not have a body content to be rendered");
}
using (parent.SetOutputStream(writer))
{
body.Call(new object[] { writer });
}
}
static object GetValue(ICallable <object> callable)
{
try
{
return(callable.Call());
}
catch (Exception exception)
{
throw new InvalidOperationException($"Could not generate value for callable [{callable}]", exception);
}
}
private void BlockTag(string tag, IDictionary attributes, ICallable block)
{
writer.WriteStartElement(tag);
if (null != attributes)
{
foreach(DictionaryEntry entry in attributes)
{
writer.WriteAttributeString((string) entry.Key, (string) entry.Value);
}
}
if (block != null)
{
block.Call(null);
}
writer.WriteEndElement();
}
public static object callSpecial(Context cx, ICallable fun, IScriptable thisObj, object [] args, IScriptable scope, IScriptable callerThis, int callType, string filename, int lineNumber)
{
if (callType == Node.SPECIALCALL_EVAL) {
if (BuiltinGlobal.isEvalFunction (fun)) {
return evalSpecial (cx, scope, callerThis, args, filename, lineNumber);
}
}
else if (callType == Node.SPECIALCALL_WITH) {
if (BuiltinWith.IsWithFunction (fun)) {
throw Context.ReportRuntimeErrorById ("msg.only.from.new", "With");
}
}
else {
throw Context.CodeBug ();
}
return fun.Call (cx, scope, thisObj, args);
}
/// <summary> Execute top call to script or function.
/// When the runtime is about to execute a script or function that will
/// create the first stack frame with scriptable code, it calls this method
/// to perform the real call. In this way execution of any script
/// happens inside this function.
/// </summary>
protected internal virtual object DoTopCall(ICallable callable, Context cx, IScriptable scope, IScriptable thisObj, object [] args)
{
return callable.Call (cx, scope, thisObj, args);
}
public static void ForEach(Context ctx, IEnumerable<object> set, ICallable func)
{
foreach (var obj in set)
{
func.Call(ctx.GameState, ctx, new[] { obj });
}
}
public static IEnumerable map(object enumerable, ICallable function)
{
if (null == enumerable) throw new ArgumentNullException("enumerable");
if (null == function) throw new ArgumentNullException("function");
object[] args = new object[1];
foreach (object item in iterator(enumerable))
{
args[0] = item;
yield return function.Call(args);
}
}
/// <summary> Call {@link
/// Callable#call(Context cx, Scriptable scope, Scriptable thisObj,
/// Object[] args)}
/// using the Context instance associated with the current thread.
/// If no Context is associated with the thread, then
/// {@link ContextFactory#makeContext()} will be called to construct
/// new Context instance. The instance will be temporary associated
/// with the thread during call to {@link ContextAction#run(Context)}.
/// <p>
/// It is allowed to use null for <tt>factory</tt> argument
/// in which case the factory associated with the scope will be
/// used to create new context instances.
///
/// </summary>
public static object Call(ContextFactory factory, ICallable callable, IScriptable scope, IScriptable thisObj, object [] args)
{
if (factory == null) {
factory = ContextFactory.Global;
}
Context cx = CurrentContext;
if (cx != null) {
object result;
if (cx.factory != null) {
result = callable.Call (cx, scope, thisObj, args);
}
else {
// Context was associated with the thread via Context.enter,
// set factory to make Context.enter/exit to be no-op
// during call
cx.factory = factory;
try {
result = callable.Call (cx, scope, thisObj, args);
}
finally {
cx.factory = null;
}
}
return result;
}
cx = PrepareNewContext (AppDomain.CurrentDomain, factory);
try {
return callable.Call (cx, scope, thisObj, args);
}
finally {
ReleaseContext (cx);
}
}
