/// <summary>
/// Gets the names of all of the variables defined by an instance.
/// </summary>
/// <param name="inst">The instance to get the variable names from</param>
/// <returns></returns>
public static TsObject[] VariableInstanceGetNames(ITsInstance inst)
{
TsObject[] arr;
int i;
switch (inst)
{
case TsInstance ts:
arr = new TsObject[ts._members.Count];
i = 0;
foreach (var key in ts._members.Keys)
{
arr[i++] = key;
}
return(arr);
case DynamicInstance di:
arr = new TsObject[di._members.Count];
i = 0;
foreach (var key in di._members.Keys)
{
arr[i++] = key;
}
return(arr);
default:
throw new InvalidOperationException($"Could not get variable names from instance of type {inst.ObjectType}");
}
}
public static TsObject Try(ITsInstance target, TsObject[] args)
{
var del = (TsDelegate)args[0];
TsObject[] delArgs = null;
if (args.Length > 1)
{
delArgs = new TsObject[args.Length - 1];
Array.Copy(args, 1, delArgs, 0, delArgs.Length);
}
var result = new DynamicInstance("obj_exception");
try
{
del.Invoke(delArgs);
result["has_error"] = false;
result["error_type"] = "";
result["error_msg"] = "";
}
catch (Exception e)
{
result["has_error"] = true;
result["error_type"] = e.GetType().Name;
result["error_msg"] = e.Message;
}
return(result);
}
public static string ObjectGetParent(ITsInstance inst)
{
if (Inherits.TryGetValue(inst.ObjectType, out var parent))
{
return(parent);
}
return("");
}
public static TsObject Choose(ITsInstance target, TsObject[] args)
{
if (args.Length == 0)
{
throw new ArgumentException("There must be at least one argument passed to Choose.");
}
return(args[Rng.Next(args.Length)]);
}
public static TsObject moniter_try_enter(ITsInstance inst, TsObject[] args)
{
if (args.Length < 1)
{
throw new ArgumentOutOfRangeException("args", "There must be at least one argument to call moniter_try_enter");
}
if (args.Length == 2)
{
return(Monitor.TryEnter(args[0].GetValue(), (int)args[1]));
}
else
{
return(Monitor.TryEnter(args[0].GetValue()));
}
}
public static TsObject InstanceCreate(ITsInstance inst, TsObject[] args)
{
var type = (string)args[0];
if (!Constructors.TryGetValue(type, out var ctor))
{
throw new ArgumentException($"Cannot create instance of '{type}': Type doesn't exist", "type");
}
TsObject[] ctorArgs = null;
if (args.Length > 1)
{
ctorArgs = new TsObject[args.Length - 1];
Array.Copy(args, 1, ctorArgs, 0, args.Length - 1);
}
return(new TsObject(ctor(ctorArgs)));
}
public static TsObject Min(ITsInstance target, TsObject[] args)
{
if (args.Length == 0)
{
throw new ArgumentOutOfRangeException("args", "You must pass in at least one value to Max");
}
var min = args[0].GetFloat();
for (var i = 1; i < args.Length; i++)
{
var num = args[i].GetFloat();
if (num < min)
{
min = num;
}
}
return(new TsObject(min));
}
public static TsObject ArrayCreate(ITsInstance target, TsObject[] args)
{
var size = args[0].GetInt();
var value = TsObject.Empty();
if (args.Length > 1)
{
value = args[1];
}
var result = new TsObject[size];
for (var i = 0; i < size; ++i)
{
result[i] = value;
}
return(new TsObject(result));
}
public static TsObject task_wait_any(ITsInstance inst, TsObject[] args)
{
var tasks = new RealTask[args.Length];
for (var i = 0; i < tasks.Length; i++)
{
tasks[i] = ((Task)args[i]).Source;
}
try
{
var result = RealTask.WaitAny(tasks);
return(CreateTaskResult(result, ""));
}
catch (AggregateException e)
{
return(CreateTaskResult(-1, e.InnerException.ToString()));
}
}
public static TsObject EventPerform(ITsInstance inst, TsObject[] args)
{
if (inst.TryGetDelegate((string)args[1], out var ev))
{
TsObject[] copy;
if (args.Length > 2)
{
copy = new TsObject[args.Length - 2];
Array.Copy(args, 2, copy, 0, copy.Length);
}
else
{
copy = null;
}
return(ev.Invoke(args[0].GetInstance(), copy));
}
return(TsObject.Empty());
}
public static TsObject CallInstanceScript(ITsInstance inst, TsObject[] args)
{
if (TsReflection.TryGetScript((string)args[1], (string)args[2], out var ev))
{
TsObject[] copy;
if (args.Length > 3)
{
copy = new TsObject[args.Length - 3];
Array.Copy(args, 3, copy, 0, copy.Length);
}
else
{
copy = null;
}
return(ev.Invoke(args[0].GetInstance(), copy));
}
return(TsObject.Empty());
}
public static TsObject task_wait_all(ITsInstance inst, TsObject[] args)
{
var tasks = new RealTask[args.Length];
for (var i = 0; i < tasks.Length; i++)
{
tasks[i] = ((Task)args[i]).Source;
}
try
{
RealTask.WaitAll(tasks);
return("");
}
catch (AggregateException e)
{
return(e.InnerException.ToString());
}
}
public static TsObject CallGlobalScript(ITsInstance inst, TsObject[] args)
{
if (args.Length < 1)
{
throw new ArgumentException("You must pass at least a script name to script_execute.");
}
var name = args[0].GetString();
if (!TsReflection.GlobalScripts.TryGetValue(name, out var function))
{
throw new ArgumentException($"Tried to execute a non-existant function: {name}");
}
var parameters = new TsObject[args.Length - 1];
if (parameters.Length != 0)
{
Array.Copy(args, 1, parameters, 0, parameters.Length);
}
return(function.Invoke(inst, parameters));
}
/// <summary>
/// Determines if an instance has a variable with the given name
/// </summary>
/// <param name="inst">The instance to check</param>
/// <param name="name">The name of the variable</param>
/// <returns></returns>
public static bool VariableInstanceExists(ITsInstance inst, string name)
{
switch (inst)
{
case TsInstance ts:
return(ts._members.ContainsKey(name));
case DynamicInstance di:
return(di._members.ContainsKey(name));
default:
try
{
inst.GetMember(name);
return(true);
}
catch
{
return(false);
}
}
}
public static TsObject TryExpect(ITsInstance target, TsObject[] args)
{
var del = (TsDelegate)args[0];
TsObject[] delArgs = null;
if (args.Length > 2)
{
delArgs = new TsObject[args.Length - 2];
Array.Copy(args, 2, delArgs, 0, delArgs.Length);
}
try
{
del.Invoke(delArgs);
}
catch (Exception e)
{
return(e.GetType().Name == (string)args[1]);
}
return(false);
}
public static TsObject TimeInvoke(ITsInstance target, TsObject[] args)
{
var del = (TsDelegate)args[0];
TsObject[] delArgs = null;
if (args.Length > 1)
{
delArgs = new TsObject[args.Length - 1];
Array.Copy(args, 1, delArgs, 0, delArgs.Length);
}
var timer = new Stopwatch();
timer.Start();
del.Invoke(delArgs);
timer.Stop();
var result = new DynamicInstance("obj_timer_result");
result["ms"] = timer.ElapsedMilliseconds;
result["ticks"] = timer.ElapsedTicks;
return(result);
}
/// <summary>
/// Sets a variable on an instance
/// </summary>
/// <param name="inst">The instance to set the variable on</param>
/// <param name="name">The name of the variable</param>
/// <param name="value">The value to set</param>
public static void VariableInstanceSet(ITsInstance inst, string name, TsObject value)
{
inst.SetMember(name, value);
}
public static TsObject task_run(ITsInstance inst, TsObject[] args)
{
return(args.Length == 1
? new Task(RealTask.Run(() => args[0].GetDelegate().Invoke()))
: new Task(RealTask.Run(() => args[0].GetDelegate().Invoke(), ((TaskCancellationToken)args[1]).Source.Token)));
}
/// <summary>
/// Gets the value of an instance variable.
/// </summary>
/// <param name="inst">The instance to get the value from</param>
/// <param name="name">The name of the variable</param>
/// <returns></returns>
public static TsObject VariableInstanceGet(ITsInstance inst, string name)
{
return(inst.GetMember(name));
}
public static TsObject thread_get_id(ITsInstance inst, TsObject[] args)
{
return(Thread.CurrentThread.ManagedThreadId);
}
/// <summary>
/// Creates a TaffyScript object from an instances id.
/// </summary>
/// <param name="instance">The instance to get the id from.</param>
public TsObject(ITsInstance instance)
{
Type = VariableType.Instance;
Value = new TsImmutableValue <ITsInstance>(instance);
}
/// <summary>
/// Creates a copy of a TsDelegate with a new target.
/// </summary>
/// <param name="original"></param>
/// <param name="target"></param>
public TsDelegate(TsDelegate original, ITsInstance target)
{
Script = original.Script;
Name = original.Name;
Target = target;
}
public static TsObject thread_pool_queue_item(ITsInstance inst, TsObject[] args)
{
return(ThreadPool.QueueUserWorkItem((obj) => args[0].GetDelegate().Invoke()));
}
public TsDelegate(TsScript script, string name, ITsInstance target)
{
Target = target;
Script = script;
Name = name;
}
public static TsObject moniter_exit(ITsInstance inst, TsObject[] args)
{
Monitor.Exit(args[0].GetValue());
return(TsObject.Empty());
}
/// <summary>
/// Invokes the wrapped script with the specified target and arguments.
/// </summary>
/// <param name="target"></param>
/// <param name="args"></param>
/// <returns></returns>
public TsObject Invoke(ITsInstance target, params TsObject[] args)
{
return(Script(target, args));
}
public static string ObjectGetName(ITsInstance inst)
{
return(inst.ObjectType);
}
public TsObject DelegateInvoke(ITsInstance target, params TsObject[] args)
{
return(GetDelegate().Invoke(target, args));
}
public static TsObject thread_sleep(ITsInstance inst, TsObject[] args)
{
Thread.Sleep((int)args[0]);
return(TsObject.Empty());
}
