void OnConnectToServer(int id)
{
Debug.Log("Connected to server as client " + id);
timeConnected = renderTime;
context.Activate();
for (int i = 0; i < MaxClients; ++i)
{
context.HideAvatar(i);
}
isConnected = true;
}
void OnConnectToServer(int clientIndex)
{
Debug.Log("Connected to server as client " + clientIndex);
timeConnected = renderTime;
context.Activate();
for (int i = 0; i < Constants.MaxClients; ++i)
{
context.HideRemoteAvatar(i);
}
successfullyConnected = true;
}
private JSValue run(Context internalContext)
{
internalContext.Activate();
JSValue result = null;
try
{
result = evaluateBody(internalContext);
}
finally
{
internalContext.Deactivate();
}
return(result);
}
/// <summary>
/// Run the script
/// </summary>
public void Run()
{
if (Code == "")
{
return;
}
try
{
Context.Activate();
_root.Evaluate(Context);
}
finally
{
Context.Deactivate();
}
}
public IIteratorResult next(Arguments args)
{
if (_generatorContext == null)
{
initContext();
}
else
{
switch (_generatorContext._executionMode)
{
case ExecutionMode.Suspend:
{
_generatorContext._executionMode = ExecutionMode.Resume;
break;
}
case ExecutionMode.ResumeThrow:
{
break;
}
default:
return(new GeneratorResult(JSValue.undefined, true));
}
;
_generatorContext._executionInfo = args != null ? args[0] : JSValue.undefined;
}
_generatorContext.Activate();
JSValue result;
try
{
result = _generator.evaluateBody(_generatorContext);
}
finally
{
_generatorContext.Deactivate();
}
return(new GeneratorResult(result, _generatorContext._executionMode != ExecutionMode.Suspend));
}
/// <summary>
/// Way 1: preloading all the data into memory and returning it inside this scope.
/// </summary>
private IEnumerator <Tuple> GetGreedyEnumerator()
{
using (var cs = Context.BeginEnumeration()) {
List <Tuple> items;
using (Context.Activate())
items = Source.ToList();
foreach (var tuple in items)
{
yield return(tuple);
}
if (cs != null)
{
cs.Complete();
}
}
}
private JSValue run(Context internalContext)
{
internalContext.Activate();
JSValue result = null;
try
{
result = evaluateBody(internalContext);
}
catch (JSException ex)
{
throw ex;
}
finally
{
internalContext.Deactivate();
}
return(result);
}
public JSValue Evaluate(Context context)
{
if (Code == "")
{
return(JSValue.Undefined);
}
try
{
context.Activate();
return(Root.Evaluate(context) ?? context._lastResult ?? JSValue.notExists);
}
finally
{
for (var i = 0; i < Root._variables.Length; i++)
{
Root._variables[i].cacheContext = null;
}
context.Deactivate();
}
}
/// <summary>
/// Way 2: batched enumeration with periodical context activation
/// </summary>
private IEnumerator <Tuple> GetBatchedEnumerator()
{
EnumerationScope currentScope = null;
var batched = Source.Batch(2).ApplyBeforeAndAfter(
() => currentScope = Context.Activate(),
() => currentScope.DisposeSafely());
using (var cs = Context.BeginEnumeration()) {
foreach (var batch in batched)
{
foreach (var tuple in batch)
{
yield return(tuple);
}
}
if (cs != null)
{
cs.Complete();
}
}
}
/// <summary>
/// Way 1: asynchroniously preloading all the data into memory and returning it inside this scope.
/// </summary>
private async Task <IEnumerator <Tuple> > GetGreedyEnumeratorAsync(CancellationToken token)
{
var cs = Context.BeginEnumeration();
List <Tuple> items;
Action <object> afterEnumrationAction =
o => {
if (o == null)
{
return;
}
var completableScope = (ICompletableScope)o;
completableScope.Complete();
completableScope.Dispose();
};
using (Context.Activate()) {
var enumerator = await Source.GetEnumeratorAsync(Context, token).ConfigureAwait(false);
items = enumerator.ToEnumerable().ToList();
}
return(items.ToEnumerator(afterEnumrationAction, cs));
}
private void evaluateWithScope(Context context, int i, bool clearSuspendData)
{
var activated = _suppressScopeIsolation != SuppressScopeIsolationMode.Suppress && context.Activate();
try
{
evaluateLines(context, i, clearSuspendData);
}
finally
{
if (_suppressScopeIsolation != SuppressScopeIsolationMode.Suppress)
{
if (activated)
{
context.Deactivate();
}
context._parent._lastResult = context._lastResult;
context._parent._executionInfo = context._executionInfo;
context._parent._executionMode = context._executionMode;
if (_variables.Length != 0)
{
clearVariablesCache();
}
}
}
}
protected internal virtual JSValue Invoke(bool construct, JSValue targetObject, Arguments arguments)
{
JSValue result;
var body = FunctionDefinition.Body;
if (body._lines.Length == 0)
{
notExists._valueType = JSValueType.NotExists;
return(notExists);
}
var ceocw = FunctionDefinition.FunctionInfo.ContainsEval || FunctionDefinition.FunctionInfo.ContainsWith || FunctionDefinition.FunctionInfo.NeedDecompose;
if (FunctionDefinition.recursionDepth > FunctionDefinition.parametersStored) // рекурсивный вызов.
{
if (!ceocw)
{
storeParameters();
}
FunctionDefinition.parametersStored = FunctionDefinition.recursionDepth;
}
if (arguments == null)
{
arguments = new Arguments(Context.CurrentContext);
}
for (;;) // tail recursion catcher
{
var internalContext = new Context(Context, ceocw, this)
{
_definedVariables = body._variables
};
internalContext.Activate();
try
{
initContext(targetObject, arguments, ceocw, internalContext);
initParameters(arguments, internalContext);
FunctionDefinition.recursionDepth++;
result = evaluateBody(internalContext);
}
finally
{
FunctionDefinition.recursionDepth--;
if (FunctionDefinition.parametersStored > FunctionDefinition.recursionDepth)
{
FunctionDefinition.parametersStored = FunctionDefinition.recursionDepth;
}
exit(internalContext);
}
if (result != null) // tail recursion
{
break;
}
arguments = internalContext._executionInfo as Arguments;
targetObject = correctTargetObject(internalContext._objectSource, body._strict);
}
return(result);
}
private JSValue fastInvoke(JSValue targetObject, Expression[] arguments, Context initiator)
{
#if DEBUG && !(PORTABLE || NETCORE)
if (_functionDefinition.trace)
{
System.Console.WriteLine("DEBUG: Run \"" + _functionDefinition.Reference.Name + "\"");
}
#endif
var body = _functionDefinition._body;
targetObject = correctTargetObject(targetObject, body._strict);
if (_functionDefinition.recursionDepth > _functionDefinition.parametersStored) // рекурсивный вызов.
{
storeParameters();
_functionDefinition.parametersStored++;
}
JSValue res = null;
Arguments args = null;
bool tailCall = false;
for (; ;)
{
var internalContext = new Context(_initialContext, false, this);
internalContext._callDepth = (Context.CurrentContext?._callDepth ?? 0) + 1;
if (_functionDefinition.kind == FunctionKind.Arrow)
{
internalContext._thisBind = _initialContext._thisBind;
}
else
{
internalContext._thisBind = targetObject;
}
if (tailCall)
{
initParameters(
args,
_functionDefinition._functionInfo.ContainsEval ||
_functionDefinition._functionInfo.ContainsWith ||
_functionDefinition._functionInfo.ContainsDebugger ||
_functionDefinition._functionInfo.NeedDecompose ||
(internalContext?._debugging ?? false),
internalContext);
}
else
{
initParametersFast(arguments, initiator, internalContext);
}
// Эта строка обязательно должна находиться после инициализации параметров
_functionDefinition.recursionDepth++;
initCachedReference(internalContext);
internalContext._strict |= body._strict;
internalContext.Activate();
try
{
res = evaluateBody(internalContext);
if (internalContext._executionMode == ExecutionMode.TailRecursion)
{
tailCall = true;
args = internalContext._executionInfo as Arguments;
}
else
{
tailCall = false;
}
}
finally
{
#if DEBUG && !(PORTABLE || NETCORE)
if (_functionDefinition.trace)
{
System.Console.WriteLine("DEBUG: Exit \"" + _functionDefinition.Reference.Name + "\"");
}
#endif
_functionDefinition.recursionDepth--;
if (_functionDefinition.parametersStored > _functionDefinition.recursionDepth)
{
_functionDefinition.parametersStored--;
}
exit(internalContext);
}
if (!tailCall)
{
break;
}
targetObject = correctTargetObject(internalContext._objectSource, body._strict);
}
return(res);
}
private JSValue fastInvoke(JSValue targetObject, Expression[] arguments, Context initiator)
{
var body = FunctionDefinition.Body;
targetObject = correctTargetObject(targetObject, body._strict);
if (FunctionDefinition.recursionDepth > FunctionDefinition.parametersStored) // рекурсивный вызов.
{
storeParameters();
FunctionDefinition.parametersStored++;
}
JSValue res = null;
Arguments args = null;
bool tailCall = false;
for (;;)
{
var internalContext = new Context(Context, false, this)
{
_thisBind = FunctionDefinition.Kind == FunctionKind.Arrow
? Context._thisBind
: targetObject
};
if (tailCall)
{
initParameters(args, internalContext);
}
else
{
initParametersFast(arguments, initiator, internalContext);
}
// Эта строка обязательно должна находиться после инициализации параметров
FunctionDefinition.recursionDepth++;
if (FunctionDefinition.Reference._descriptor != null && FunctionDefinition.Reference._descriptor.cacheRes == null)
{
FunctionDefinition.Reference._descriptor.cacheContext = internalContext._parent;
FunctionDefinition.Reference._descriptor.cacheRes = this;
}
internalContext._strict |= body._strict;
internalContext.Activate();
try
{
res = evaluateBody(internalContext);
if (internalContext._executionMode == ExecutionMode.TailRecursion)
{
tailCall = true;
args = internalContext._executionInfo as Arguments;
}
else
{
tailCall = false;
}
}
finally
{
FunctionDefinition.recursionDepth--;
if (FunctionDefinition.parametersStored > FunctionDefinition.recursionDepth)
{
FunctionDefinition.parametersStored--;
}
exit(internalContext);
}
if (!tailCall)
{
break;
}
targetObject = correctTargetObject(internalContext._objectSource, body._strict);
}
return(res);
}
