public virtual void setLocalVar(int i, VSMXBaseObject value)
{
if (i > 0 && i <= localVariables.Length)
{
localVariables[i - 1] = value;
}
}
public InterpretFunctionAction(VSMXInterpreter outerInstance, VSMXFunction function, VSMXBaseObject @object, VSMXBaseObject[] arguments)
{
this.outerInstance = outerInstance;
this.function = function;
this.@object = @object;
this.arguments = arguments;
}
private void callFunction(VSMXFunction function, VSMXBaseObject thisObject, VSMXBaseObject[] arguments, int numberArguments, bool returnThis)
{
pushCallState(thisObject, function.LocalVars + function.Args, returnThis, false);
for (int i = 1; i <= function.Args && i <= numberArguments; i++)
{
callState.setLocalVar(i, arguments[i - 1]);
}
function.call(callState);
int startLine = function.StartLine;
if (startLine >= 0 && startLine < mem.codes.Length)
{
pc = startLine;
}
else
{
popCallState();
VSMXBaseObject returnValue = function.ReturnValue;
if (returnThis)
{
stack.Push(thisObject);
}
else if (returnValue != null)
{
stack.Push(returnValue);
}
}
}
public override void setPropertyValue(string name, VSMXBaseObject value)
{
if (lengthName.Equals(name))
{
int newLength = value.IntValue;
if (newLength > Length)
{
for (int i = Length; i < newLength; i++)
{
create(i);
}
}
else if (newLength < Length)
{
for (int i = newLength; i < Length; i++)
{
delete(i);
}
}
return;
}
int index = getIndex(name);
if (index >= 0)
{
setPropertyValue(index, value);
}
else
{
base.setPropertyValue(name, value);
}
}
public override void setPropertyValue(string name, VSMXBaseObject value)
{
if (@object != null && !string.ReferenceEquals(name, null) && name.Length >= 1 && value is VSMXNativeObject)
{
string setterName = "set" + char.ToUpper(name[0]) + name.Substring(1);
try
{
Method setterMethod = @object.GetType().GetMethod(setterName, typeof(BaseNativeObject));
setterMethod.invoke(@object, ((VSMXNativeObject)value).Object);
return;
}
catch (NoSuchMethodException)
{
// Ignore exception
}
catch (SecurityException)
{
// Ignore exception
}
catch (IllegalAccessException)
{
// Ignore exception
}
catch (System.ArgumentException)
{
// Ignore exception
}
catch (InvocationTargetException)
{
// Ignore exception
}
}
base.setPropertyValue(name, value);
}
public override void setPropertyValue(int index, VSMXBaseObject value)
{
if (index >= 0)
{
updateLength(index);
base.setPropertyValue(Convert.ToString(index), value);
}
}
public override bool identity(VSMXBaseObject value)
{
if (value is VSMXString)
{
return(StringValue.Equals(value.StringValue));
}
return(base.identity(value));
}
public virtual void delayInterpretFunction(VSMXFunction function, VSMXBaseObject @object, VSMXBaseObject[] arguments)
{
lock (this)
{
IAction action = new InterpretFunctionAction(this, function, @object, arguments);
Emulator.Scheduler.addAction(action);
}
}
public override bool Equals(VSMXBaseObject value)
{
if (value is VSMXObject)
{
// Return true if both values refer to the same object
return(this == value);
}
return(false);
}
private VSMXBaseObject[] popValues(int n)
{
VSMXBaseObject[] values = new VSMXBaseObject[n];
for (int i = n - 1; i >= 0; i--)
{
values[i] = stack.Pop().Value;
}
return(values);
}
private void pushCallState(VSMXBaseObject thisObject, int numberOfLocalVariables, bool returnThis, bool exitAfterCall)
{
if (callState != null)
{
callStates.Push(callState);
}
callState = new VSMXCallState(thisObject, numberOfLocalVariables, pc, returnThis, exitAfterCall);
stack = callState.Stack;
prefix += " ";
}
public VSMXCallState(VSMXBaseObject thisObject, int numberOfLocalVariables, int returnPc, bool returnThis, bool exitAfterCall)
{
this.thisObject = thisObject;
localVariables = new VSMXBaseObject[numberOfLocalVariables];
Arrays.Fill(localVariables, VSMXUndefined.singleton);
stack = new Stack <VSMXBaseObject>();
this.returnPc = returnPc;
this.returnThis = returnThis;
this.exitAfterCall = exitAfterCall;
}
public virtual VSMXBaseObject Substring(VSMXBaseObject @object, VSMXBaseObject start)
{
string s = StringValue;
int beginIndex = start.IntValue;
beginIndex = System.Math.Max(beginIndex, 0);
beginIndex = System.Math.Min(beginIndex, s.Length);
return(new VSMXString(Interpreter, s.Substring(beginIndex)));
}
public override void setPropertyValue(string name, VSMXBaseObject value)
{
if (properties.ContainsKey(name))
{
properties[name] = value;
}
else
{
addProperty(name, value);
}
}
public virtual void assign(VSMXBaseObject value)
{
if (string.ReferenceEquals(refProperty, null))
{
refObject.setPropertyValue(refIndex, value.Value);
}
else
{
refObject.setPropertyValue(refProperty, value.Value);
}
}
public override bool Equals(VSMXBaseObject value)
{
if (value is VSMXArray)
{
// Empty arrays are always equal
if (Length == 0 && ((VSMXArray)value).Length == 0)
{
return(true);
}
}
return(base.Equals(value));
}
public virtual VSMXFunction getFunction(int numberOfArguments, VSMXBaseObject[] arguments)
{
this.numberOfArguments = numberOfArguments;
this.arguments = arguments;
thisObject = @object.Value;
if (@object.hasPropertyValue(name))
{
VSMXBaseObject function = @object.getPropertyValue(name).Value;
if (function != null && function is VSMXFunction)
{
return((VSMXFunction)function);
}
}
if (@object is VSMXFunction && callName.Equals(name))
{
// The first argument of the "call()" function call is the "this" object.
if (numberOfArguments > 0)
{
this.numberOfArguments--;
if (arguments.Length > 0)
{
thisObject = arguments[0];
this.arguments = new VSMXBaseObject[this.numberOfArguments];
Array.Copy(arguments, 1, this.arguments, 0, this.numberOfArguments);
}
}
return((VSMXFunction)@object);
}
INativeFunction nativeFunction = null;
if (@object is VSMXNativeObject)
{
VSMXNativeObject nativeObject = (VSMXNativeObject)@object;
nativeFunction = NativeFunctionFactory.Instance.getNativeFunction(nativeObject, name, numberOfArguments);
}
else if (@object is VSMXBaseObject)
{
nativeFunction = NativeFunctionFactory.Instance.getNativeFunction(@object, name, numberOfArguments);
}
if (nativeFunction != null)
{
return(new VSMXNativeFunction(interpreter, nativeFunction));
}
return(null);
}
public override VSMXBaseObject getPropertyValue(string name)
{
if (lengthName.Equals(name))
{
return(new VSMXNumber(interpreter, properties.Count));
}
if (prototypeName.Equals(name))
{
VSMXObject prototype = Prototype;
if (prototype != null)
{
return(prototype);
}
return(VSMXUndefined.singleton);
}
VSMXBaseObject value = properties[name];
if (value == null)
{
int index = getIndex(name);
if (index >= 0)
{
if (index < properties.Count)
{
value = properties[sortedPropertyNames[index]];
}
else
{
value = VSMXUndefined.singleton;
}
}
else
{
VSMXObject prototype = Prototype;
if (prototype != null && prototype.properties.ContainsKey(name))
{
value = prototype.getPropertyValue(name);
}
else
{
value = VSMXUndefined.singleton;
addProperty(name, value);
}
}
}
return(value);
}
protected internal virtual void ToString(StringBuilder s)
{
string[] keys = properties.Keys.toArray(new string[0]);
Array.Sort(keys);
foreach (string key in keys)
{
VSMXBaseObject value = properties[key];
if (s.Length > 1)
{
s.Append(",\n");
}
s.Append(string.Format("{0}={1}", key, value));
}
}
public virtual VSMXBaseObject charAt(VSMXBaseObject @object, VSMXBaseObject index)
{
string s = StringValue;
int i = index.IntValue;
if (i < 0 || i >= s.Length)
{
return(new VSMXString(interpreter, ""));
}
char c = s[i];
return(new VSMXString(interpreter, "" + c));
}
public virtual VSMXBaseObject lastIndexOf(VSMXBaseObject @object, VSMXBaseObject Substring, VSMXBaseObject startIndex)
{
int startIndexInt = startIndex.IntValue;
string substringString = Substring.StringValue;
string s = StringValue;
if (startIndexInt < 0)
{
startIndexInt = 0;
}
else if (startIndexInt > s.Length)
{
startIndexInt = s.Length;
}
int lastIndexOfInt = s.LastIndexOf(substringString, startIndexInt, StringComparison.Ordinal);
return(new VSMXNumber(interpreter, lastIndexOfInt));
}
public virtual void interpretFunction(VSMXFunction function, VSMXBaseObject @object, VSMXBaseObject[] arguments)
{
lock (this)
{
pushCallState(@object, function.LocalVars, false, true);
for (int i = 1; i <= function.Args; i++)
{
if (arguments == null || i > arguments.Length)
{
callState.setLocalVar(i, VSMXNull.singleton);
}
else
{
callState.setLocalVar(i, arguments[i - 1]);
}
}
pc = function.StartLine;
interpret();
}
}
public virtual void interpretScript(VSMXBaseObject @object, string script)
{
lock (this)
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("interpretScript {0} on {1}", script, @object));
}
if (string.ReferenceEquals(script, null))
{
return;
}
if (@object == null)
{
@object = VSMXNull.singleton;
}
string scriptPrefix = string.Format("script:/{0}/", name);
if (script.StartsWith(scriptPrefix, StringComparison.Ordinal))
{
string functionName = script.Substring(scriptPrefix.Length);
VSMXBaseObject functionObject = globalVariables.getPropertyValue(functionName);
if (functionObject is VSMXFunction)
{
VSMXFunction function = (VSMXFunction)functionObject;
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("interpretScript function={0}", function));
}
interpretFunction(function, @object, null);
}
}
else
{
Console.WriteLine(string.Format("interpretScript unknown script syntax '{0}'", script));
}
}
}
public virtual VSMXBaseObject Substring(VSMXBaseObject @object, VSMXBaseObject start, VSMXBaseObject end)
{
string s = StringValue;
int beginIndex = start.IntValue;
beginIndex = System.Math.Max(beginIndex, 0);
beginIndex = System.Math.Min(beginIndex, s.Length);
int endIndex = end.IntValue;
endIndex = System.Math.Max(endIndex, 0);
endIndex = System.Math.Min(endIndex, s.Length);
// The Substring method uses the lower value of start and end as the beginning point of the Substring.
if (beginIndex > endIndex)
{
int tmp = beginIndex;
beginIndex = endIndex;
endIndex = tmp;
}
return(new VSMXString(Interpreter, s.Substring(beginIndex, endIndex - beginIndex)));
}
public override void setPropertyValue(string name, VSMXBaseObject value)
{
Ref.setPropertyValue(name, value);
}
public override bool Equals(VSMXBaseObject value)
{
return(Ref.Equals(value));
}
private void addProperty(string name, VSMXBaseObject value)
{
properties[name] = value;
sortedPropertyNames.Add(name);
}
public virtual VSMXBaseObject toLowerCase(VSMXBaseObject @object)
{
return(new VSMXString(Interpreter, StringValue.ToLower()));
}
public virtual VSMXBaseObject lastIndexOf(VSMXBaseObject @object, VSMXBaseObject Substring)
{
return(lastIndexOf(@object, Substring, new VSMXNumber(interpreter, @object.StringValue.Length)));
}
public override bool Equals(VSMXBaseObject value)
{
return(StringValue.Equals(value.StringValue));
}
