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)); }