def isfinitejs(ctx, args, this): if len(args) < 1: return newbool(True) n = args[0].ToNumber(ctx) if isinf(n) or isnan(n): return newbool(False) else: return newbool(True)
def Call(self, ctx, args=[], this=None): if len(args) >= 1 and isinstance(args[0], W_PrimitiveObject): O = this V = args[0].Prototype while V is not None: if O == V: return newbool(True) V = V.Prototype return newbool(False)
def Construct(self, ctx, args=[]): if len(args) >= 1 and not isnull_or_undefined(args[0]): Value = newbool(args[0].ToBoolean()) return create_object(ctx, 'Boolean', Value = Value) return create_object(ctx, 'Boolean', Value = newbool(False))
def __init__(self): allon = DE | DD | RO global_instance = W_Object(Class="global") ctx = global_context(global_instance) w_ObjPrototype = W_Object(Prototype=None, Class='Object') w_Function = W_Function(ctx, Class='Function', Prototype=w_ObjPrototype) w_FncPrototype = W_Function(ctx, Class='Function', Prototype=w_ObjPrototype) w_Function.Put(ctx, 'prototype', w_FncPrototype, flags = allon) w_Function.Put(ctx, 'length', W_IntNumber(1), flags = allon) w_Function.Put(ctx, 'constructor', w_Function, flags=allon) global_instance.Put(ctx, 'Function', w_Function) global_instance.Prototype = w_ObjPrototype w_Object = W_ObjectObject('Object', w_FncPrototype) w_Object.Put(ctx, 'prototype', w_ObjPrototype, flags = allon) w_Object.Put(ctx, 'length', W_IntNumber(1), flags = allon) global_instance.Put(ctx, 'Object', w_Object) toString = W_ToString(ctx) put_values(ctx, w_ObjPrototype, { 'constructor': w_Object, '__proto__': w_Null, 'toString': toString, 'toLocaleString': toString, 'valueOf': W_ValueOf(ctx), 'hasOwnProperty': W_HasOwnProperty(ctx), 'isPrototypeOf': W_IsPrototypeOf(ctx), 'propertyIsEnumerable': W_PropertyIsEnumerable(ctx), }) #properties of the function prototype put_values(ctx, w_FncPrototype, { 'constructor': w_Function, '__proto__': w_FncPrototype, 'toString': W_FToString(ctx), 'apply': W_Apply(ctx), 'call': W_Call(ctx), 'arguments': w_Null, 'valueOf': W_ValueOf(ctx), }) w_Boolean = W_BooleanObject('Boolean', w_FncPrototype) w_Boolean.Put(ctx, 'constructor', w_FncPrototype, flags = allon) w_Boolean.Put(ctx, 'length', W_IntNumber(1), flags = allon) w_BoolPrototype = create_object(ctx, 'Object', Value=newbool(False)) w_BoolPrototype.Class = 'Boolean' put_values(ctx, w_BoolPrototype, { 'constructor': w_FncPrototype, '__proto__': w_ObjPrototype, 'toString': W_BooleanValueToString(ctx), 'valueOf': get_value_of('Boolean')(ctx), }) w_Boolean.Put(ctx, 'prototype', w_BoolPrototype, flags = allon) global_instance.Put(ctx, 'Boolean', w_Boolean) #Number w_Number = W_NumberObject('Number', w_FncPrototype) w_empty_fun = w_Function.Call(ctx, args=[W_String('')]) w_NumPrototype = create_object(ctx, 'Object', Value=W_FloatNumber(0.0)) w_NumPrototype.Class = 'Number' put_values(ctx, w_NumPrototype, { 'constructor': w_Number, '__proto__': w_empty_fun, 'toString': W_NumberValueToString(ctx), 'valueOf': get_value_of('Number')(ctx), }) put_values(ctx, w_Number, { 'constructor': w_FncPrototype, 'prototype': w_NumPrototype, '__proto__': w_FncPrototype, 'length' : W_IntNumber(1), }) w_Number.propdict['prototype'].flags |= RO w_Number.Put(ctx, 'MAX_VALUE', W_FloatNumber(1.7976931348623157e308), flags = RO|DD) w_Number.Put(ctx, 'MIN_VALUE', W_FloatNumber(0), flags = RO|DD) w_Number.Put(ctx, 'NaN', W_FloatNumber(NAN), flags = RO|DD) # ^^^ this is exactly in test case suite w_Number.Put(ctx, 'POSITIVE_INFINITY', W_FloatNumber(INFINITY), flags = RO|DD) w_Number.Put(ctx, 'NEGATIVE_INFINITY', W_FloatNumber(-INFINITY), flags = RO|DD) global_instance.Put(ctx, 'Number', w_Number) #String w_String = W_StringObject('String', w_FncPrototype) w_StrPrototype = create_object(ctx, 'Object', Value=W_String('')) w_StrPrototype.Class = 'String' w_StrPrototype.Put(ctx, 'length', W_IntNumber(0)) put_values(ctx, w_StrPrototype, { 'constructor': w_String, '__proto__': w_StrPrototype, 'toString': W_StringValueToString(ctx), 'valueOf': get_value_of('String')(ctx), 'charAt': W_CharAt(ctx), 'charCodeAt': W_CharCodeAt(ctx), 'concat': W_Concat(ctx), 'indexOf': W_IndexOf(ctx), 'lastIndexOf': W_LastIndexOf(ctx), 'substring': W_Substring(ctx), 'split': W_Split(ctx), 'toLowerCase': W_ToLowerCase(ctx), 'toUpperCase': W_ToUpperCase(ctx) }) w_String.Put(ctx, 'prototype', w_StrPrototype, flags=allon) w_String.Put(ctx, 'fromCharCode', W_FromCharCode(ctx)) global_instance.Put(ctx, 'String', w_String) w_Array = W_ArrayObject('Array', w_FncPrototype) w_ArrPrototype = W_Array(Prototype=w_ObjPrototype) put_values(ctx, w_ArrPrototype, { 'constructor': w_FncPrototype, '__proto__': w_ArrPrototype, 'toString': W_ArrayToString(ctx), 'join': W_ArrayJoin(ctx), 'reverse': W_ArrayReverse(ctx), 'sort': W_ArraySort(ctx), 'push': W_ArrayPush(ctx), 'pop': W_ArrayPop(ctx), }) w_Array.Put(ctx, 'prototype', w_ArrPrototype, flags = allon) w_Array.Put(ctx, '__proto__', w_FncPrototype, flags = allon) w_Array.Put(ctx, 'length', W_IntNumber(1), flags = allon) global_instance.Put(ctx, 'Array', w_Array) #Math w_math = W_Object(Class='Math') global_instance.Put(ctx, 'Math', w_math) w_math.Put(ctx, '__proto__', w_ObjPrototype) w_math.Put(ctx, 'prototype', w_ObjPrototype, flags = allon) w_math.Put(ctx, 'abs', W_Builtin(absjs, Class='function')) w_math.Put(ctx, 'floor', W_Builtin(floorjs, Class='function')) w_math.Put(ctx, 'round', W_Builtin(roundjs, Class='function')) w_math.Put(ctx, 'pow', W_Builtin(powjs, Class='function')) w_math.Put(ctx, 'sqrt', W_Builtin(sqrtjs, Class='function')) w_math.Put(ctx, 'log', W_Builtin(logjs, Class='function')) w_math.Put(ctx, 'E', W_FloatNumber(math.e), flags=allon) w_math.Put(ctx, 'LN2', W_FloatNumber(math.log(2)), flags=allon) w_math.Put(ctx, 'LN10', W_FloatNumber(math.log(10)), flags=allon) log2e = math.log(math.e) / math.log(2) # rpython supports log with one argument only w_math.Put(ctx, 'LOG2E', W_FloatNumber(log2e), flags=allon) w_math.Put(ctx, 'LOG10E', W_FloatNumber(math.log10(math.e)), flags=allon) w_math.Put(ctx, 'PI', W_FloatNumber(math.pi), flags=allon) w_math.Put(ctx, 'SQRT1_2', W_FloatNumber(math.sqrt(0.5)), flags=allon) w_math.Put(ctx, 'SQRT2', W_FloatNumber(math.sqrt(2)), flags=allon) w_math.Put(ctx, 'random', W_Builtin(randomjs, Class='function')) w_math.Put(ctx, 'min', W_Builtin(minjs, Class='function')) w_math.Put(ctx, 'max', W_Builtin(maxjs, Class='function')) global_instance.Put(ctx, 'version', W_Builtin(versionjs), flags=allon) #Date w_Date = W_DateObject('Date', w_FncPrototype) w_DatePrototype = create_object(ctx, 'Object', Value=W_String('')) w_DatePrototype.Class = 'Date' put_values(ctx, w_DatePrototype, { '__proto__': w_DatePrototype, 'valueOf': get_value_of('Date')(ctx), 'getTime': get_value_of('Date')(ctx) }) w_Date.Put(ctx, 'prototype', w_DatePrototype, flags=allon) global_instance.Put(ctx, 'Date', w_Date) global_instance.Put(ctx, 'NaN', W_FloatNumber(NAN), flags = DE|DD) global_instance.Put(ctx, 'Infinity', W_FloatNumber(INFINITY), flags = DE|DD) global_instance.Put(ctx, 'undefined', w_Undefined, flags = DE|DD) put_values(ctx, global_instance, { 'this': global_instance, 'eval': W_Eval(ctx), 'parseInt': W_ParseInt(ctx), 'parseFloat': W_ParseFloat(ctx), 'isNaN': W_Builtin(isnanjs), 'isFinite': W_Builtin(isfinitejs), 'print': W_Builtin(printjs), 'alert': W_Builtin(noop), 'unescape': W_Builtin(unescapejs), 'load': W_Builtin(make_loadjs(self)) }) # debugging if not we_are_translated(): global_instance.Put(ctx, 'pypy_repr', W_Builtin(pypy_repr)) self.global_context = ctx self.w_Global = global_instance self.w_Object = w_Object
def Call(self, ctx, args=[], this=None): if len(args) >= 1 and not isnull_or_undefined(args[0]): return newbool(args[0].ToBoolean()) else: return newbool(False)
def Call(self, ctx, args=[], this=None): if len(args) >= 1: propname = args[0].ToString(ctx) if propname in this.propdict and not this.propdict[propname].flags & DE: return newbool(True) return newbool(False)
def eval(self, ctx, stack): stack.append(newbool(self.boolval))
def isnanjs(ctx, args, this): if len(args) < 1: return newbool(True) return newbool(isnan(args[0].ToNumber(ctx)))
def eval(self, ctx, stack): stack.append(newbool(ctx.delete_identifier(self.name)))
def eval(self, ctx, stack): what = stack.pop().ToString(ctx) obj = stack.pop().ToObject(ctx) stack.append(newbool(obj.Delete(what)))
def decision(self, ctx, op1, op2): return newbool(not StrictEC(ctx, op1, op2))
def decision(self, ctx, op1, op2): return newbool(not AbstractEC(ctx, op1, op2))
def decision(self, ctx, op1, op2): return newbool(compare_e(ctx, op2, op1))
def eval(self, ctx, stack): stack.append(newbool(not stack.pop().ToBoolean()))
def operation(self, ctx, left, right): if not isinstance(right, W_Object): raise ThrowException(W_String("TypeError")) name = left.ToString(ctx) return newbool(right.HasProperty(name))