public object Invoke(DispatchIdentifier id, DispatchType dispType, JsValue[] args, out Type returnType) { if (id.Tag == DispatchIdentifierType.String) { if (id.AsString == "length") { return GetLength(dispType, out returnType); } else { returnType = typeof(void); return null; } } else { int intId = id.AsInt; if (intId == this.target.Length) { return GetLength(dispType, out returnType); } if (intId >= 0 && intId < this.target.Length) { Debug.WriteLine(string.Format("{0}, {1}[{2}]", dispType, this.target, id)); if (dispType == DispatchType.PropertyGet) { returnType = this.elementType; return this.target.GetValue(intId); } if (dispType == DispatchType.PropertySet) { object value = this.bridge.UnwrapValue(args.First(), this.elementType); this.target.SetValue(value, intId); returnType = typeof(void); return null; } } } throw new NotSupportedException(); }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-15.2.2.1 /// </summary> /// <param name="arguments"></param> /// <returns></returns> public ObjectInstance Construct(JsValue[] arguments) { if (arguments.Length > 0) { var value = arguments[0]; var valueObj = value.TryCast<ObjectInstance>(); if (valueObj != null) { return valueObj; } var type = value.Type; if (type == Types.String || type == Types.Number || type == Types.Boolean) { return TypeConverter.ToObject(_engine, value); } } var obj = new ObjectInstance(_engine) { Extensible = true, Prototype = Engine.Object.PrototypeObject }; return obj; }
private JsValue Bind(JsValue thisObj, JsValue[] arguments) { var target = thisObj.TryCast<ICallable>(x => { throw new JavaScriptException(Engine.TypeError); }); var thisArg = arguments.At(0); var f = new BindFunctionInstance(Engine) {Extensible = true}; f.TargetFunction = thisObj; f.BoundThis = thisArg; f.BoundArgs = arguments.Skip(1).ToArray(); f.Prototype = Engine.Function.PrototypeObject; var o = target as FunctionInstance; if (o != null) { var l = TypeConverter.ToNumber(o.Get("length")) - (arguments.Length - 1); f.FastAddProperty("length", System.Math.Max(l, 0), false, false, false); } else { f.FastAddProperty("length", 0, false, false, false); } var thrower = Engine.Function.ThrowTypeError; f.DefineOwnProperty("caller", new PropertyDescriptor(thrower, thrower, false, false), false); f.DefineOwnProperty("arguments", new PropertyDescriptor(thrower, thrower, false, false), false); return f; }
public object Invoke(DispatchIdentifier id, DispatchType dispType, JsValue[] jsArgs, out Type returnType) { MemberInfo member = GetMember(id.AsString); if (member == null) { returnType = typeof(void); return null; } Debug.WriteLine(string.Format("{0}, {1}.{2}", dispType, this.target, member.Name)); if (member is MethodInfo && dispType == DispatchType.PropertyGet) { var method = (MethodInfo)member; return GetMethodAsProperty((MethodInfo)member, this.target, out returnType); } var args = this.bridge.UnwrapParameters(jsArgs, dispType, member); if (dispType.IsMethod()) { var method = (MethodBase)member; returnType = method.IsConstructor ? method.DeclaringType : ((MethodInfo)method).ReturnType; return method.Invoke(this.target, args); } if (dispType.IsPropertyGet()) { var pi = (PropertyInfo)member; returnType = pi.PropertyType; return pi.GetValue(this.target, null); } if (dispType.IsPropertyPut()) { var pi = (PropertyInfo)member; pi.SetValue(this.target, args.First(), null); returnType = typeof(void); return null; } throw new NotSupportedException(); }
public JsValue Call(JsValue thisObject, JsValue[] arguments) { // direct calls on a NamespaceReference constructor object is creating a generic type var genericTypes = new Type[arguments.Length]; for (int i = 0; i < arguments.Length; i++) { var genericTypeReference = arguments.At(i); if (genericTypeReference == Undefined.Instance || !genericTypeReference.IsObject() || genericTypeReference.AsObject().Class != "TypeReference") { throw new JavaScriptException(Engine.TypeError, "Invalid generic type parameter"); } genericTypes[i] = arguments.At(0).As<TypeReference>().Type; } var typeReference = GetPath(_path + "`" + arguments.Length.ToString(CultureInfo.InvariantCulture)).As<TypeReference>(); if (typeReference == null) { return Undefined.Instance; } var genericType = typeReference.Type.MakeGenericType(genericTypes); return TypeReference.CreateTypeReference(Engine, genericType); }
/// Implementation from ObjectInstance official specs as the one /// in ObjectInstance is optimized for the general case and wouldn't work /// for arrays public override void Put(string propertyName, JsValue value, bool throwOnError) { if (!CanPut(propertyName)) { if (throwOnError) { throw new JavaScriptException(Engine.TypeError); } return; } var ownDesc = GetOwnProperty(propertyName); if (ownDesc.IsDataDescriptor()) { var valueDesc = new PropertyDescriptor(value: value, writable: null, enumerable: null, configurable: null); DefineOwnProperty(propertyName, valueDesc, throwOnError); return; } // property is an accessor or inherited var desc = GetProperty(propertyName); if (desc.IsAccessorDescriptor()) { var setter = desc.Set.Value.TryCast<ICallable>(); setter.Call(new JsValue(this), new[] { value }); } else { var newDesc = new PropertyDescriptor(value, true, true, true); DefineOwnProperty(propertyName, newDesc, throwOnError); } }
public virtual bool HasInstance(JsValue v) { var vObj = v.TryCast<ObjectInstance>(); if (vObj == null) { return false; } var po = Get("prototype"); if (!po.IsObject()) { throw new JavaScriptException(_engine.TypeError, string.Format("Function has non-object prototype '{0}' in instanceof check", TypeConverter.ToString(po))); } var o = po.AsObject(); if (o == null) { throw new JavaScriptException(_engine.TypeError); } while (true) { vObj = vObj.Prototype; if (vObj == null) { return false; } if (vObj == o) { return true; } } }
public JsValue Stringify(JsValue thisObject, JsValue[] arguments) { JsValue value = Undefined.Instance, replacer = Undefined.Instance, space = Undefined.Instance; if (arguments.Length > 2) { space = arguments[2]; } if (arguments.Length > 1) { replacer = arguments[1]; } if (arguments.Length > 0) { value = arguments[0]; } var serializer = new JsonSerializer(_engine); if (value == Undefined.Instance && replacer == Undefined.Instance) { return Undefined.Instance; } else { return serializer.Serialize(value, replacer, space); } }
public override void Put(string propertyName, JsValue value, bool throwOnError) { if (!CanPut(propertyName)) { if (throwOnError) { throw new JavaScriptException(Engine.TypeError); } return; } var ownDesc = GetOwnProperty(propertyName); if (ownDesc == null) { if (throwOnError) { throw new JavaScriptException(Engine.TypeError, "Unknown member: " + propertyName); } else { return; } } ownDesc.Value = value; }
public JsValue ToString(JsValue thisObject, JsValue[] arguments) { var o = thisObject.TryCast<ObjectInstance>(); if (o == null) { throw new JavaScriptException(Engine.TypeError); } var name = TypeConverter.ToString(o.Get("name")); var msgProp = o.Get("message"); string msg; if (msgProp == Undefined.Instance) { msg = ""; } else { msg = TypeConverter.ToString(msgProp); } if (name == "") { return msg; } if (msg == "") { return name; } return name + ": " + msg; }
private JsValue IsPrototypeOf(JsValue thisObject, JsValue[] arguments) { var arg = arguments[0]; if (!arg.IsObject()) { return false; } var v = arg.AsObject(); var o = TypeConverter.ToObject(Engine, thisObject); while (true) { v = v.Prototype; if (v == null) { return false; } if (o == v) { return true; } } }
private JsValue Parse(JsValue thisObj, JsValue[] arguments) { DateTime result; var date = TypeConverter.ToString(arguments.At(0)); if (!DateTime.TryParseExact(date, new[] { "yyyy-MM-ddTHH:mm:ss.FFF", "yyyy-MM-ddTHH:mm:ss", "yyyy-MM-ddTHH:mm", "yyyy-MM-dd", "yyyy-MM", "yyyy" }, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out result)) { if (!DateTime.TryParseExact(date, new[] { // Formats used in DatePrototype toString methods "ddd MMM dd yyyy HH:mm:ss 'GMT'K", "ddd MMM dd yyyy", "HH:mm:ss 'GMT'K", // standard formats "yyyy-M-dTH:m:s.FFFK", "yyyy/M/dTH:m:s.FFFK", "yyyy-M-dTH:m:sK", "yyyy/M/dTH:m:sK", "yyyy-M-dTH:mK", "yyyy/M/dTH:mK", "yyyy-M-d H:m:s.FFFK", "yyyy/M/d H:m:s.FFFK", "yyyy-M-d H:m:sK", "yyyy/M/d H:m:sK", "yyyy-M-d H:mK", "yyyy/M/d H:mK", "yyyy-M-dK", "yyyy/M/dK", "yyyy-MK", "yyyy/MK", "yyyyK", "THH:mm:ss.FFFK", "THH:mm:ssK", "THH:mmK", "THHK" }, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out result)) { if (!DateTime.TryParse(date, Engine.Options.GetCulture(), DateTimeStyles.AdjustToUniversal, out result)) { if (!DateTime.TryParse(date, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out result)) { // unrecognized dates should return NaN (15.9.4.2) return double.NaN; } } } } return FromDateTime(result); }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-13.2.1 /// </summary> /// <param name="thisArg"></param> /// <param name="arguments"></param> /// <returns></returns> public override JsValue Call(JsValue thisArg, JsValue[] arguments) { using (new StrictModeScope(Strict, true)) { // setup new execution context http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.3 JsValue thisBinding; if (StrictModeScope.IsStrictModeCode) { thisBinding = thisArg; } else if (thisArg == Undefined.Instance || thisArg == Null.Instance) { thisBinding = Engine.Global; } else if (!thisArg.IsObject()) { thisBinding = TypeConverter.ToObject(Engine, thisArg); } else { thisBinding = thisArg; } var localEnv = LexicalEnvironment.NewDeclarativeEnvironment(Engine, Scope); Engine.EnterExecutionContext(localEnv, localEnv, thisBinding); try { Engine.DeclarationBindingInstantiation( DeclarationBindingType.FunctionCode, _functionDeclaration.FunctionDeclarations, _functionDeclaration.VariableDeclarations, this, arguments); var result = Engine.ExecuteStatement(_functionDeclaration.Body); if (result.Type == Completion.Throw) { JavaScriptException ex = new JavaScriptException(result.GetValueOrDefault()); ex.Location = result.Location; throw ex; } if (result.Type == Completion.Return) { return result.GetValueOrDefault(); } } finally { Engine.LeaveExecutionContext(); } return Undefined.Instance; } }
public static ArgumentsInstance CreateArgumentsObject(Engine engine, FunctionInstance func, string[] names, JsValue[] args, EnvironmentRecord env, bool strict) { var obj = new ArgumentsInstance(engine, self => { var len = args.Length; self.FastAddProperty("length", len, true, false, true); var map = engine.Object.Construct(Arguments.Empty); var mappedNamed = new List<string>(); var indx = 0; while (indx <= len - 1) { var indxStr = TypeConverter.ToString(indx); var val = args[indx]; self.FastAddProperty(indxStr, val, true, true, true); if (indx < names.Length) { var name = names[indx]; if (!strict && !mappedNamed.Contains(name)) { mappedNamed.Add(name); Func<JsValue, JsValue> g = n => env.GetBindingValue(name, false); var p = new Action<JsValue, JsValue>((n, o) => env.SetMutableBinding(name, o, true)); map.DefineOwnProperty(indxStr, new ClrAccessDescriptor(engine, g, p) { Configurable = true }, false); } } indx++; } // step 12 if (mappedNamed.Count > 0) { self.ParameterMap = map; } // step 13 if (!strict) { self.FastAddProperty("callee", func, true, false, true); } // step 14 else { var thrower = engine.Function.ThrowTypeError; self.DefineOwnProperty("caller", new PropertyDescriptor(get: thrower, set: thrower, enumerable: false, configurable: false), false); self.DefineOwnProperty("callee", new PropertyDescriptor(get: thrower, set: thrower, enumerable: false, configurable: false), false); } }); // These properties are pre-initialized as their don't trigger // the EnsureInitialized() event and are cheap obj.Prototype = engine.Object.PrototypeObject; obj.Extensible = true; obj.Strict = strict; return obj; }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.2.2 /// </summary> public static JsValue ParseInt(JsValue thisObject, JsValue[] arguments) { string inputString = TypeConverter.ToString(arguments.At(0)); var s = inputString.Trim(); var sign = 1; if (!System.String.IsNullOrEmpty(s)) { if (s[0] == '-') { sign = -1; } if (s[0] == '-' || s[0] == '+') { s = s.Substring(1); } } var stripPrefix = true; int radix = arguments.Length > 1 ? TypeConverter.ToInt32(arguments[1]) : 0; if (radix == 0) { if (s.Length >= 2 && s.StartsWith("0x") || s.StartsWith("0X")) { radix = 16; } else { radix = 10; } } else if (radix < 2 || radix > 36) { return double.NaN; } else if(radix != 16) { stripPrefix = false; } if (stripPrefix && s.Length >= 2 && s.StartsWith("0x") || s.StartsWith("0X")) { s = s.Substring(2); } try { return sign * Parse(s, radix).AsNumber(); } catch { return double.NaN; } }
public override JsValue Call(JsValue thisObject, JsValue[] arguments) { if (arguments.Length == 0) { return ""; } return TypeConverter.ToString(arguments[0]); }
public override JsValue Call(JsValue thisObject, JsValue[] arguments) { if (arguments.Length == 0) { return false; } return TypeConverter.ToBoolean(arguments[0]); }
public override JsValue Call(JsValue thisObject, JsValue[] arguments) { var f = TargetFunction.TryCast<FunctionInstance>(x => { throw new JavaScriptException(Engine.TypeError); }); return f.Call(BoundThis, BoundArgs.Union(arguments).ToArray()); }
public ObjectInstance Construct(JsValue[] arguments) { var target = TargetFunction.TryCast<IConstructor>(x => { throw new JavaScriptException(Engine.TypeError); }); return target.Construct(BoundArgs.Union(arguments).ToArray()); }
public override bool HasInstance(JsValue v) { var f = TargetFunction.TryCast<FunctionInstance>(x => { throw new JavaScriptException(Engine.TypeError); }); return f.HasInstance(v); }
public static bool IsArrayIndex(JsValue p, out uint index) { index = ParseArrayIndex(TypeConverter.ToString(p)); return index != uint.MaxValue; // 15.4 - Use an optimized version of the specification // return TypeConverter.ToString(index) == TypeConverter.ToString(p) && index != uint.MaxValue; }
private JsValue ToRegExpString(JsValue thisObj, JsValue[] arguments) { var regExp = thisObj.TryCast<RegExpInstance>(); return "/" + regExp.Source + "/" + (regExp.Flags.Contains("g") ? "g" : "") + (regExp.Flags.Contains("i") ? "i" : "") + (regExp.Flags.Contains("m") ? "m" : "") ; }
private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments) { var o = TypeConverter.ToObject(Engine, thisObject); var toString = o.Get("toString").TryCast<ICallable>(x => { throw new JavaScriptException(Engine.TypeError); }); return toString.Call(o, Arguments.Empty); }
private static JsValue FromCharCode(JsValue thisObj, JsValue[] arguments) { var chars = new char[arguments.Length]; for (var i = 0; i < chars.Length; i++ ) { chars[i] = (char)TypeConverter.ToUint16(arguments[i]); } return new System.String(chars); }
private JsValue ValueOf(JsValue thisObj, JsValue[] arguments) { var number = thisObj.TryCast<NumberInstance>(); if (number == null) { throw new JavaScriptException(Engine.TypeError); } return number.PrimitiveValue; }
private JsValue ToStringString(JsValue thisObj, JsValue[] arguments) { var s = TypeConverter.ToObject(Engine, thisObj) as StringInstance; if (s == null) { throw new JavaScriptException(Engine.TypeError); } return s.PrimitiveValue; }
private JsValue IsArray(JsValue thisObj, JsValue[] arguments) { if (arguments.Length == 0) { return false; } var o = arguments.At(0); return o.IsObject() && o.AsObject().Class == "Array"; }
private JsValue PropertyIsEnumerable(JsValue thisObject, JsValue[] arguments) { var p = TypeConverter.ToString(arguments[0]); var o = TypeConverter.ToObject(Engine, thisObject); var desc = o.GetOwnProperty(p); if (desc == PropertyDescriptor.Undefined) { return false; } return desc.Enumerable.HasValue && desc.Enumerable.Value.AsBoolean(); }
private JsValue ToString(JsValue thisObj, JsValue[] arguments) { var func = thisObj.TryCast<FunctionInstance>(); if (func == null) { throw new JavaScriptException(Engine.TypeError, "Function object expected."); } return System.String.Format("function() {{ ... }}"); }
private JsValue Test(JsValue thisObj, JsValue[] arguments) { var r = TypeConverter.ToObject(Engine, thisObj); if (r.Class != "RegExp") { throw new JavaScriptException(Engine.TypeError); } var match = Exec(r, arguments); return match != Null.Instance; }
/// <summary> /// Returns the arguments at the provided position or Undefined if not present /// </summary> /// <param name="args"></param> /// <param name="index">The index of the parameter to return</param> /// <param name="undefinedValue">The value to return is the parameter is not provided</param> /// <returns></returns> public static JsValue At(this JsValue[] args, int index, JsValue undefinedValue) { return(args.Length > index ? args[index] : undefinedValue); }
private JsValue Now(JsValue thisObj, JsValue[] arguments) { return(System.Math.Floor((DateTime.UtcNow - Epoch).TotalMilliseconds)); }
public override JsValue Call(JsValue thisObject, JsValue[] arguments) { return(PrototypeObject.ToString(Construct(Arguments.Empty), Arguments.Empty)); }
private static JsValue ToLocaleUpperCase(JsValue thisObj, JsValue[] arguments) { var s = TypeConverter.ToString(thisObj); return(s.ToUpper()); }
private JsValue Split(JsValue thisObj, JsValue[] arguments) { TypeConverter.CheckObjectCoercible(Engine, thisObj); var s = TypeConverter.ToString(thisObj); var separator = arguments.At(0); // Coerce into a number, true will become 1 var l = arguments.At(1); var a = (ArrayInstance)Engine.Array.Construct(Arguments.Empty); var limit = l == Undefined.Instance ? UInt32.MaxValue : TypeConverter.ToUint32(l); var len = s.Length; if (limit == 0) { return(a); } if (separator == Null.Instance) { separator = Null.Text; } else if (separator == Undefined.Instance) { return((ArrayInstance)Engine.Array.Construct(Arguments.From(s))); } else { if (!separator.IsRegExp()) { separator = TypeConverter.ToString(separator); // Coerce into a string, for an object call toString() } } var rx = TypeConverter.ToObject(Engine, separator) as RegExpInstance; const string regExpForMatchingAllCharactere = "(?:)"; if (rx != null && rx.Source != regExpForMatchingAllCharactere // We need pattern to be defined -> for s.split(new RegExp) ) { var match = rx.Value.Match(s, 0); if (!match.Success) // No match at all return the string in an array { a.DefineOwnProperty("0", new PropertyDescriptor(s, true, true, true), false); return(a); } int lastIndex = 0; int index = 0; while (match.Success && index < limit) { if (match.Length == 0 && (match.Index == 0 || match.Index == len || match.Index == lastIndex)) { match = match.NextMatch(); continue; } // Add the match results to the array. a.DefineOwnProperty(index++.ToString(), new PropertyDescriptor(s.Substring(lastIndex, match.Index - lastIndex), true, true, true), false); if (index >= limit) { return(a); } lastIndex = match.Index + match.Length; for (int i = 1; i < match.Groups.Count; i++) { var group = match.Groups[i]; var item = Undefined.Instance; if (group.Captures.Count > 0) { item = match.Groups[i].Value; } a.DefineOwnProperty(index++.ToString(), new PropertyDescriptor(item, true, true, true), false); if (index >= limit) { return(a); } } match = match.NextMatch(); if (!match.Success) // Add the last part of the split { a.DefineOwnProperty(index++.ToString(), new PropertyDescriptor(s.Substring(lastIndex), true, true, true), false); } } return(a); } else { var segments = new List <string>(); var sep = TypeConverter.ToString(separator); if (sep == string.Empty || (rx != null && rx.Source == regExpForMatchingAllCharactere)) // for s.split(new RegExp) { foreach (var c in s) { segments.Add(c.ToString()); } } else { segments = s.Split(new[] { sep }, StringSplitOptions.None).ToList(); } for (int i = 0; i < segments.Count && i < limit; i++) { a.DefineOwnProperty(i.ToString(), new PropertyDescriptor(segments[i], true, true, true), false); } return(a); } }
protected override void AddLoadedCounter(JsValue reference, string name, long value) { throw new NotSupportedException("Counters aren't supported by SQL ETL"); }
protected override void AddLoadedTimeSeries(JsValue reference, string name, IEnumerable <SingleResult> entries) { throw new NotSupportedException("Time series aren't supported by SQL ETL"); }
public Engine SetValue(string name, JsValue value) { Global.Put(name, value, false); return(this); }
internal static JsValue TriggerPromiseReactions(Engine engine, List <PromiseReaction> reactions, JsValue result) { foreach (var reaction in reactions) { engine.AddToEventLoop(NewPromiseReactionJob(reaction, result)); } return(JsValue.Undefined); }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3.4 /// </summary> /// <param name="thisObject"></param> /// <param name="arguments"></param> /// <returns></returns> public JsValue EncodeUriComponent(JsValue thisObject, JsValue[] arguments) { var uriString = TypeConverter.ToString(arguments.At(0)); return(Encode(uriString, UriUnescaped)); }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.2.4 /// </summary> public static JsValue IsNaN(JsValue thisObject, JsValue[] arguments) { var x = TypeConverter.ToNumber(arguments.At(0)); return(double.IsNaN(x)); }
/// <summary> /// http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.2.3 /// </summary> public static JsValue ParseFloat(JsValue thisObject, JsValue[] arguments) { var inputString = TypeConverter.ToString(arguments.At(0)); var trimmedString = StringPrototype.TrimStartEx(inputString); var sign = 1; if (trimmedString.Length > 0) { if (trimmedString[0] == '-') { sign = -1; trimmedString = trimmedString.Substring(1); } else if (trimmedString[0] == '+') { trimmedString = trimmedString.Substring(1); } } if (trimmedString.StartsWith("Infinity")) { return(sign * double.PositiveInfinity); } if (trimmedString.StartsWith("NaN")) { return(double.NaN); } var separator = (char)0; bool isNan = true; decimal number = 0; var i = 0; for (; i < trimmedString.Length; i++) { var c = trimmedString[i]; if (c == '.') { i++; separator = '.'; break; } if (c == 'e' || c == 'E') { i++; separator = 'e'; break; } var digit = c - '0'; if (digit >= 0 && digit <= 9) { isNan = false; number = number * 10 + digit; } else { break; } } decimal pow = 0.1m; if (separator == '.') { for (; i < trimmedString.Length; i++) { var c = trimmedString[i]; var digit = c - '0'; if (digit >= 0 && digit <= 9) { isNan = false; number += digit * pow; pow *= 0.1m; } else if (c == 'e' || c == 'E') { i++; separator = 'e'; break; } else { break; } } } var exp = 0; var expSign = 1; if (separator == 'e') { if (i < trimmedString.Length) { if (trimmedString[i] == '-') { expSign = -1; i++; } else if (trimmedString[i] == '+') { i++; } } for (; i < trimmedString.Length; i++) { var c = trimmedString[i]; var digit = c - '0'; if (digit >= 0 && digit <= 9) { exp = exp * 10 + digit; } else { break; } } } if (isNan) { return(double.NaN); } for (var k = 1; k <= exp; k++) { if (expSign > 0) { number *= 10; } else { number /= 10; } } return((double)(sign * number)); }
public ExecutionContext EnterExecutionContext(LexicalEnvironment lexicalEnvironment, LexicalEnvironment variableEnvironment, JsValue thisBinding) { var executionContext = new ExecutionContext { LexicalEnvironment = lexicalEnvironment, VariableEnvironment = variableEnvironment, ThisBinding = thisBinding }; _executionContexts.Push(executionContext); return(executionContext); }
public JsValue Serialize(JsValue value, JsValue replacer, JsValue space) { _stack = new Stack <object>(); // for JSON.stringify(), any function passed as the first argument will return undefined // if the replacer is not defined. The function is not called either. if (value.Is <ICallable>() && replacer == Undefined.Instance) { return(Undefined.Instance); } if (replacer.IsObject()) { if (replacer.Is <ICallable>()) { _replacerFunction = replacer; } else { var replacerObj = replacer.AsObject(); if (replacerObj.Class == "Array") { _propertyList = new List <string>(); } foreach (var property in replacerObj.GetOwnProperties().Select(x => x.Value)) { JsValue v = _engine.GetValue(property); string item = null; if (v.IsString()) { item = v.AsString(); } else if (v.IsNumber()) { item = TypeConverter.ToString(v); } else if (v.IsObject()) { var propertyObj = v.AsObject(); if (propertyObj.Class == "String" || propertyObj.Class == "Number") { item = TypeConverter.ToString(v); } } if (item != null && !_propertyList.Contains(item)) { _propertyList.Add(item); } } } } if (space.IsObject()) { var spaceObj = space.AsObject(); if (spaceObj.Class == "Number") { space = TypeConverter.ToNumber(spaceObj); } else if (spaceObj.Class == "String") { space = TypeConverter.ToString(spaceObj); } } // defining the gap if (space.IsNumber()) { if (space.AsNumber() > 0) { _gap = new System.String(' ', (int)System.Math.Min(10, space.AsNumber())); } else { _gap = string.Empty; } } else if (space.IsString()) { var stringSpace = space.AsString(); _gap = stringSpace.Length <= 10 ? stringSpace : stringSpace.Substring(0, 10); } else { _gap = string.Empty; } var wrapper = _engine.Object.Construct(Arguments.Empty); wrapper.DefineOwnProperty("", new PropertyDescriptor(value, true, true, true), false); return(Str("", wrapper)); }
public void Init() { instance = new JsValue(); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(JsValue obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
public override JsValue Call(JsValue thisObject, JsValue[] arguments) { // direct calls on a TypeReference constructor object is equivalent to the new operator return(Construct(arguments)); }
protected abstract void AddLoadedCounter(JsValue reference, string name, long value);
private JsValue Replace(JsValue thisObj, JsValue[] arguments) { TypeConverter.CheckObjectCoercible(Engine, thisObj); var thisString = TypeConverter.ToString(thisObj); var searchValue = arguments.At(0); var replaceValue = arguments.At(1); // If the second parameter is not a function we create one var replaceFunction = replaceValue.TryCast <FunctionInstance>(); if (replaceFunction == null) { replaceFunction = new ClrFunctionInstance(Engine, (self, args) => { var replaceString = TypeConverter.ToString(replaceValue); var matchValue = TypeConverter.ToString(args.At(0)); var matchIndex = (int)TypeConverter.ToInteger(args.At(args.Length - 2)); // Check if the replacement string contains any patterns. bool replaceTextContainsPattern = replaceString.IndexOf('$') >= 0; // If there is no pattern, replace the pattern as is. if (replaceTextContainsPattern == false) { return(replaceString); } // Patterns // $$ Inserts a "$". // $& Inserts the matched substring. // $` Inserts the portion of the string that precedes the matched substring. // $' Inserts the portion of the string that follows the matched substring. // $n or $nn Where n or nn are decimal digits, inserts the nth parenthesized submatch string, provided the first argument was a RegExp object. var replacementBuilder = new StringBuilder(); for (int i = 0; i < replaceString.Length; i++) { char c = replaceString[i]; if (c == '$' && i < replaceString.Length - 1) { c = replaceString[++i]; if (c == '$') { replacementBuilder.Append('$'); } else if (c == '&') { replacementBuilder.Append(matchValue); } else if (c == '`') { replacementBuilder.Append(thisString.Substring(0, matchIndex)); } else if (c == '\'') { replacementBuilder.Append(thisString.Substring(matchIndex + matchValue.Length)); } else if (c >= '0' && c <= '9') { int matchNumber1 = c - '0'; // The match number can be one or two digits long. int matchNumber2 = 0; if (i < replaceString.Length - 1 && replaceString[i + 1] >= '0' && replaceString[i + 1] <= '9') { matchNumber2 = matchNumber1 * 10 + (replaceString[i + 1] - '0'); } // Try the two digit capture first. if (matchNumber2 > 0 && matchNumber2 < args.Length - 2) { // Two digit capture replacement. replacementBuilder.Append(TypeConverter.ToString(args[matchNumber2])); i++; } else if (matchNumber1 > 0 && matchNumber1 < args.Length - 2) { // Single digit capture replacement. replacementBuilder.Append(TypeConverter.ToString(args[matchNumber1])); } else { // Capture does not exist. replacementBuilder.Append('$'); i--; } } else { // Unknown replacement pattern. replacementBuilder.Append('$'); replacementBuilder.Append(c); } } else { replacementBuilder.Append(c); } } return(replacementBuilder.ToString()); }); } // searchValue is a regular expression if (searchValue.IsNull()) { searchValue = new JsValue(Null.Text); } if (searchValue.IsUndefined()) { searchValue = new JsValue(Undefined.Text); } var rx = TypeConverter.ToObject(Engine, searchValue) as RegExpInstance; if (rx != null) { // Replace the input string with replaceText, recording the last match found. string result = rx.Value.Replace(thisString, match => { var args = new List <JsValue>(); for (var k = 0; k < match.Groups.Count; k++) { var group = match.Groups[k]; args.Add(group.Value); } args.Add(match.Index); args.Add(thisString); var v = TypeConverter.ToString(replaceFunction.Call(Undefined.Instance, args.ToArray())); return(v); }, rx.Global == true ? -1 : 1); // Set the deprecated RegExp properties if at least one match was found. //if (lastMatch != null) // this.Engine.RegExp.SetDeprecatedProperties(input, lastMatch); return(result); } // searchValue is a string else { var substr = TypeConverter.ToString(searchValue); // Find the first occurrance of substr. int start = thisString.IndexOf(substr, StringComparison.Ordinal); if (start == -1) { return(thisString); } int end = start + substr.Length; var args = new List <JsValue>(); args.Add(substr); args.Add(start); args.Add(thisString); var replaceString = TypeConverter.ToString(replaceFunction.Call(Undefined.Instance, args.ToArray())); // Replace only the first match. var result = new StringBuilder(thisString.Length + (substr.Length - substr.Length)); result.Append(thisString, 0, start); result.Append(replaceString); result.Append(thisString, end, thisString.Length - end); return(result.ToString()); } }
protected abstract void AddLoadedAttachment(JsValue reference, string name, Attachment attachment);
private static JsValue ToLowerCase(JsValue thisObj, JsValue[] arguments) { var s = TypeConverter.ToString(thisObj); return(s.ToLowerInvariant()); }
/// <summary> /// Invoke the current value as function. /// </summary> /// <param name="value">The function to call.</param> /// <param name="thisObj">The this value inside the function call.</param> /// <param name="arguments">The arguments of the function call.</param> /// <returns>The value returned by the function call.</returns> public JsValue Invoke(JsValue value, object thisObj, object[] arguments) { var callable = value.TryCast <ICallable>(); if (callable == null) { throw new ArgumentException("Can only invoke functions"); } return(callable.Call(JsValue.FromObject(this, thisObj), arguments.Select(x => JsValue.FromObject(this, x)).ToArray())); }
public JsValue Invoke(MethodInfo[] methodInfos, JsValue thisObject, JsValue[] jsArguments) { var arguments = ProcessParamsArrays(jsArguments, methodInfos); var methods = TypeConverter.FindBestMatch(Engine, methodInfos, arguments).ToList(); var converter = Engine.ClrTypeConverter; foreach (var method in methods) { var parameters = new object[arguments.Length]; var argumentsMatch = true; for (var i = 0; i < arguments.Length; i++) { var parameterType = method.GetParameters()[i].ParameterType; if (parameterType == typeof(JsValue)) { parameters[i] = arguments[i]; } else if (parameterType == typeof(JsValue[]) && arguments[i].IsArray()) { // Handle specific case of F(params JsValue[]) var arrayInstance = arguments[i].AsArray(); var len = TypeConverter.ToInt32(arrayInstance.Get("length")); var result = new JsValue[len]; for (var k = 0; k < len; k++) { var pk = k.ToString(); result[k] = arrayInstance.HasProperty(pk) ? arrayInstance.Get(pk) : JsValue.Undefined; } parameters[i] = result; } else { if (!converter.TryConvert(arguments[i].ToObject(), parameterType, CultureInfo.InvariantCulture, out parameters[i])) { argumentsMatch = false; break; } var lambdaExpression = parameters[i] as LambdaExpression; if (lambdaExpression != null) { parameters[i] = lambdaExpression.Compile(); } } } if (!argumentsMatch) { continue; } // todo: cache method info return(JsValue.FromObject(Engine, method.Invoke(thisObject.ToObject(), parameters.ToArray()))); } throw new JavaScriptException(Engine.TypeError, "No public methods with the specified arguments were found."); }
/// <summary> /// Invoke the current value as function. /// </summary> /// <param name="value">The function to call.</param> /// <param name="arguments">The arguments of the function call.</param> /// <returns>The value returned by the function call.</returns> public JsValue Invoke(JsValue value, params object[] arguments) { return(Invoke(value, null, arguments)); }
public override JsValue Call(JsValue thisObject, JsValue[] arguments) { return(Invoke(_methods, thisObject, arguments)); }
public Engine SetValue(string name, Object obj) { return(SetValue(name, JsValue.FromObject(this, obj))); }
public static IDocumentType ToDoctype(JsValue arg) { return(null); }
private JsValue Utc(JsValue thisObj, JsValue[] arguments) { return(TimeClip(ConstructTimeValue(arguments, useUtc: true))); }
public static IWindow ToWindow(JsValue arg) { return(null); }
public static IMessagePort ToMessagePort(JsValue arg) { return(null); }