/[jscoverage]/trunk/js/jsbuiltins.cpp
ViewVC logotype

Diff of /trunk/js/jsbuiltins.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 332 by siliconforks, Thu Oct 23 19:03:33 2008 UTC revision 399 by siliconforks, Tue Dec 9 03:37:47 2008 UTC
# Line 1  Line 1 
1  /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-  /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4; -*-
2   * vim: set ts=8 sw=4 et tw=99:   * vim: set ts=8 sw=4 et tw=99:
3   *   *
4   * ***** BEGIN LICENSE BLOCK *****   * ***** BEGIN LICENSE BLOCK *****
# Line 52  Line 52 
52  #include "jsmath.h"  #include "jsmath.h"
53  #include "jsnum.h"  #include "jsnum.h"
54  #include "prmjtime.h"  #include "prmjtime.h"
55    #include "jsdate.h"
56  #include "jsscope.h"  #include "jsscope.h"
57  #include "jsstr.h"  #include "jsstr.h"
58    #include "jsbuiltins.h"
59  #include "jstracer.h"  #include "jstracer.h"
60    
 #include "nanojit/avmplus.h"  
 #include "nanojit/nanojit.h"  
   
61  using namespace avmplus;  using namespace avmplus;
62  using namespace nanojit;  using namespace nanojit;
63    
64    extern jsdouble js_NaN;
65    
66  /*  /*
67   * NB: bool FASTCALL is not compatible with Nanojit's calling convention usage.   * NB: bool FASTCALL is not compatible with Nanojit's calling convention usage.
68   * Do not use bool FASTCALL, use JSBool only!   * Do not use bool FASTCALL, use JSBool only!
# Line 87  Line 88 
88      return r;      return r;
89  }  }
90    
91  jsint FASTCALL  int32 FASTCALL
92  js_imod(jsint a, jsint b)  js_imod(int32 a, int32 b)
93  {  {
94      if (a < 0 || b <= 0)      if (a < 0 || b <= 0)
95          return -1;          return -1;
# Line 103  Line 104 
104  jsval FASTCALL  jsval FASTCALL
105  js_BoxDouble(JSContext* cx, jsdouble d)  js_BoxDouble(JSContext* cx, jsdouble d)
106  {  {
107      jsint i;      int32 i;
108      if (JSDOUBLE_IS_INT(d, i))      if (JSDOUBLE_IS_INT(d, i) && INT_FITS_IN_JSVAL(i))
109          return INT_TO_JSVAL(i);          return INT_TO_JSVAL(i);
110      JS_ASSERT(JS_ON_TRACE(cx));      JS_ASSERT(JS_ON_TRACE(cx));
111      jsval v; /* not rooted but ok here because we know GC won't run */      jsval v; /* not rooted but ok here because we know GC won't run */
# Line 114  Line 115 
115  }  }
116    
117  jsval FASTCALL  jsval FASTCALL
118  js_BoxInt32(JSContext* cx, jsint i)  js_BoxInt32(JSContext* cx, int32 i)
119  {  {
120      if (JS_LIKELY(INT_FITS_IN_JSVAL(i)))      if (JS_LIKELY(INT_FITS_IN_JSVAL(i)))
121          return INT_TO_JSVAL(i);          return INT_TO_JSVAL(i);
# Line 134  Line 135 
135      return *JSVAL_TO_DOUBLE(v);      return *JSVAL_TO_DOUBLE(v);
136  }  }
137    
138  jsint FASTCALL  int32 FASTCALL
139  js_UnboxInt32(jsval v)  js_UnboxInt32(jsval v)
140  {  {
141      if (JS_LIKELY(JSVAL_IS_INT(v)))      if (JS_LIKELY(JSVAL_IS_INT(v)))
# Line 148  Line 149 
149      return js_DoubleToECMAInt32(d);      return js_DoubleToECMAInt32(d);
150  }  }
151    
152  int32 FASTCALL  uint32 FASTCALL
153  js_DoubleToUint32(jsdouble d)  js_DoubleToUint32(jsdouble d)
154  {  {
155      return js_DoubleToECMAUint32(d);      return js_DoubleToECMAUint32(d);
156  }  }
157    
158  jsdouble FASTCALL  jsdouble FASTCALL
 js_Math_sin(jsdouble d)  
 {  
     return sin(d);  
 }  
   
 jsdouble FASTCALL  
 js_Math_cos(jsdouble d)  
 {  
     return cos(d);  
 }  
   
 jsdouble FASTCALL  
 js_Math_floor(jsdouble d)  
 {  
     return floor(d);  
 }  
   
 jsdouble FASTCALL  
 js_Math_ceil(jsdouble d)  
 {  
     return ceil(d);  
 }  
   
 extern jsdouble js_NaN;  
   
 jsdouble FASTCALL  
 js_Math_pow(jsdouble d, jsdouble p)  
 {  
     if (!JSDOUBLE_IS_FINITE(p) && (d == 1.0 || d == -1.0))  
         return js_NaN;  
     if (p == 0)  
         return 1.0;  
     return pow(d, p);  
 }  
   
 jsdouble FASTCALL  
 js_Math_sqrt(jsdouble d)  
 {  
     return sqrt(d);  
 }  
   
 jsdouble FASTCALL  
 js_Math_log(jsdouble d)  
 {  
 #if !JS_USE_FDLIBM_MATH && defined(SOLARIS) && defined(__GNUC__)  
     if (d < 0)  
         return js_NaN;  
 #endif  
     return log(d);  
 }  
   
 jsdouble FASTCALL  
 js_Math_max(jsdouble d, jsdouble p)  
 {  
     if (JSDOUBLE_IS_NaN(d) || JSDOUBLE_IS_NaN(p))  
         return js_NaN;  
   
     if (p == 0 && p == d && fd_copysign(1.0, d) == -1)  
         return p;  
     return (d > p) ? d : p;  
 }  
   
 JSBool FASTCALL  
 js_Array_dense_setelem(JSContext* cx, JSObject* obj, jsint i, jsval v)  
 {  
     JS_ASSERT(OBJ_IS_DENSE_ARRAY(cx, obj));  
   
     jsuint length = ARRAY_DENSE_LENGTH(obj);  
     if ((jsuint)i < length) {  
         if (obj->dslots[i] == JSVAL_HOLE) {  
             if (i >= obj->fslots[JSSLOT_ARRAY_LENGTH])  
                 obj->fslots[JSSLOT_ARRAY_LENGTH] = i + 1;  
             obj->fslots[JSSLOT_ARRAY_COUNT]++;  
         }  
         obj->dslots[i] = v;  
         return JS_TRUE;  
     }  
     return OBJ_SET_PROPERTY(cx, obj, INT_TO_JSID(i), &v);  
 }  
   
 JSString* FASTCALL  
 js_Array_p_join(JSContext* cx, JSObject* obj, JSString *str)  
 {  
     jsval v;  
     if (!js_array_join_sub(cx, obj, TO_STRING, str, &v))  
         return NULL;  
     JS_ASSERT(JSVAL_IS_STRING(v));  
     return JSVAL_TO_STRING(v);  
 }  
   
 jsval FASTCALL  
 js_Array_p_push1(JSContext* cx, JSObject* obj, jsval v)  
 {  
     if (!(OBJ_IS_DENSE_ARRAY(cx, obj)  
           ? js_array_push1_dense(cx, obj, v, &v)  
           : js_array_push_slowly(cx, obj, 1, &v, &v))) {  
         return JSVAL_ERROR_COOKIE;  
     }  
     return v;  
 }  
   
 jsval FASTCALL  
 js_Array_p_pop(JSContext* cx, JSObject* obj)  
 {  
     jsval v;  
     if (!(OBJ_IS_DENSE_ARRAY(cx, obj)  
           ? js_array_pop_dense(cx, obj, &v)  
           : js_array_pop_slowly(cx, obj, &v))) {  
         return JSVAL_ERROR_COOKIE;  
     }  
     return v;  
 }  
   
 JSString* FASTCALL  
 js_String_p_substring(JSContext* cx, JSString* str, jsint begin, jsint end)  
 {  
     JS_ASSERT(end >= begin);  
     JS_ASSERT(JS_ON_TRACE(cx));  
     return js_NewDependentString(cx, str, (size_t)begin, (size_t)(end - begin));  
 }  
   
 JSString* FASTCALL  
 js_String_p_substring_1(JSContext* cx, JSString* str, jsint begin)  
 {  
     jsint end = JSSTRING_LENGTH(str);  
     JS_ASSERT(end >= begin);  
     JS_ASSERT(JS_ON_TRACE(cx));  
     return js_NewDependentString(cx, str, (size_t)begin, (size_t)(end - begin));  
 }  
   
 JSString* FASTCALL  
 js_String_getelem(JSContext* cx, JSString* str, jsint i)  
 {  
     if ((size_t)i >= JSSTRING_LENGTH(str))  
         return NULL;  
     return js_GetUnitString(cx, str, (size_t)i);  
 }  
   
 JSString* FASTCALL  
 js_String_fromCharCode(JSContext* cx, jsint i)  
 {  
     JS_ASSERT(JS_ON_TRACE(cx));  
     jschar c = (jschar)i;  
     if (c < UNIT_STRING_LIMIT)  
         return js_GetUnitStringForChar(cx, c);  
     return js_NewStringCopyN(cx, &c, 1);  
 }  
   
 jsint FASTCALL  
 js_String_p_charCodeAt(JSString* str, jsint i)  
 {  
     if (i < 0 || (jsint)JSSTRING_LENGTH(str) <= i)  
         return -1;  
     return JSSTRING_CHARS(str)[i];  
 }  
   
 jsdouble FASTCALL  
 js_Math_random(JSRuntime* rt)  
 {  
     JS_LOCK_RUNTIME(rt);  
     js_random_init(rt);  
     jsdouble z = js_random_nextDouble(rt);  
     JS_UNLOCK_RUNTIME(rt);  
     return z;  
 }  
   
 JSString* FASTCALL  
 js_String_p_concat_1int(JSContext* cx, JSString* str, jsint i)  
 {  
     // FIXME: should be able to use stack buffer and avoid istr...  
     JSString* istr = js_NumberToString(cx, i);  
     if (!istr)  
         return NULL;  
     return js_ConcatStrings(cx, str, istr);  
 }  
   
 JSString* FASTCALL  
 js_String_p_concat_2str(JSContext* cx, JSString* str, JSString* a, JSString* b)  
 {  
     str = js_ConcatStrings(cx, str, a);  
     if (str)  
         return js_ConcatStrings(cx, str, b);  
     return NULL;  
 }  
   
 JSString* FASTCALL  
 js_String_p_concat_3str(JSContext* cx, JSString* str, JSString* a, JSString* b, JSString* c)  
 {  
     str = js_ConcatStrings(cx, str, a);  
     if (str) {  
         str = js_ConcatStrings(cx, str, b);  
         if (str)  
             return js_ConcatStrings(cx, str, c);  
     }  
     return NULL;  
 }  
   
 JSObject* FASTCALL  
 js_String_p_match(JSContext* cx, JSString* str, jsbytecode *pc, JSObject* regexp)  
 {  
     jsval vp[3] = { JSVAL_NULL, STRING_TO_JSVAL(str), OBJECT_TO_JSVAL(regexp) };  
     if (!js_StringMatchHelper(cx, 1, vp, pc))  
         return (JSObject*) JSVAL_TO_BOOLEAN(JSVAL_VOID);  
     JS_ASSERT(JSVAL_IS_NULL(vp[0]) ||  
               (!JSVAL_IS_PRIMITIVE(vp[0]) && OBJ_IS_ARRAY(cx, JSVAL_TO_OBJECT(vp[0]))));  
     return JSVAL_TO_OBJECT(vp[0]);  
 }  
   
 JSObject* FASTCALL  
 js_String_p_match_obj(JSContext* cx, JSObject* str, jsbytecode *pc, JSObject* regexp)  
 {  
     jsval vp[3] = { JSVAL_NULL, OBJECT_TO_JSVAL(str), OBJECT_TO_JSVAL(regexp) };  
     if (!js_StringMatchHelper(cx, 1, vp, pc))  
         return (JSObject*) JSVAL_TO_BOOLEAN(JSVAL_VOID);  
     JS_ASSERT(JSVAL_IS_NULL(vp[0]) ||  
               (!JSVAL_IS_PRIMITIVE(vp[0]) && OBJ_IS_ARRAY(cx, JSVAL_TO_OBJECT(vp[0]))));  
     return JSVAL_TO_OBJECT(vp[0]);  
 }  
   
 JSString* FASTCALL  
 js_String_p_replace_str(JSContext* cx, JSString* str, JSObject* regexp, JSString* repstr)  
 {  
     jsval vp[4] = {  
         JSVAL_NULL, STRING_TO_JSVAL(str), OBJECT_TO_JSVAL(regexp), STRING_TO_JSVAL(repstr)  
     };  
     if (!js_StringReplaceHelper(cx, 2, NULL, repstr, vp))  
         return NULL;  
     JS_ASSERT(JSVAL_IS_STRING(vp[0]));  
     return JSVAL_TO_STRING(vp[0]);  
 }  
   
 JSString* FASTCALL  
 js_String_p_replace_str2(JSContext* cx, JSString* str, JSString* patstr, JSString* repstr)  
 {  
     jsval vp[4] = {  
         JSVAL_NULL, STRING_TO_JSVAL(str), STRING_TO_JSVAL(patstr), STRING_TO_JSVAL(repstr)  
     };  
     if (!js_StringReplaceHelper(cx, 2, NULL, repstr, vp))  
         return NULL;  
     JS_ASSERT(JSVAL_IS_STRING(vp[0]));  
     return JSVAL_TO_STRING(vp[0]);  
 }  
   
 JSString* FASTCALL  
 js_String_p_replace_str3(JSContext* cx, JSString* str, JSString* patstr, JSString* repstr,  
                          JSString* flagstr)  
 {  
     jsval vp[5] = {  
         JSVAL_NULL, STRING_TO_JSVAL(str), STRING_TO_JSVAL(patstr), STRING_TO_JSVAL(repstr),  
         STRING_TO_JSVAL(flagstr)  
     };  
     if (!js_StringReplaceHelper(cx, 3, NULL, repstr, vp))  
         return NULL;  
     JS_ASSERT(JSVAL_IS_STRING(vp[0]));  
     return JSVAL_TO_STRING(vp[0]);  
 }  
   
 JSObject* FASTCALL  
 js_String_p_split(JSContext* cx, JSString* str, JSString* sepstr)  
 {  
     // FIXME: optimize by calling into a lower level exported from jsstr.cpp.  
     jsval vp[4] = { JSVAL_NULL, STRING_TO_JSVAL(str), STRING_TO_JSVAL(sepstr), JSVAL_VOID };  
     if (!js_str_split(cx, 2, vp))  
         return NULL;  
     JS_ASSERT(JSVAL_IS_OBJECT(vp[0]));  
     return JSVAL_TO_OBJECT(vp[0]);  
 }  
   
 jsdouble FASTCALL  
159  js_StringToNumber(JSContext* cx, JSString* str)  js_StringToNumber(JSContext* cx, JSString* str)
160  {  {
161      const jschar* bp;      const jschar* bp;
# Line 441  Line 173 
173      return d;      return d;
174  }  }
175    
176  jsint FASTCALL  int32 FASTCALL
177  js_StringToInt32(JSContext* cx, JSString* str)  js_StringToInt32(JSContext* cx, JSString* str)
178  {  {
179      const jschar* bp;      const jschar* bp;
# Line 452  Line 184 
184      JSSTRING_CHARS_AND_END(str, bp, end);      JSSTRING_CHARS_AND_END(str, bp, end);
185      if (!js_strtod(cx, bp, end, &ep, &d) || js_SkipWhiteSpace(ep, end) != end)      if (!js_strtod(cx, bp, end, &ep, &d) || js_SkipWhiteSpace(ep, end) != end)
186          return 0;          return 0;
187      return (jsint)d;      return js_DoubleToECMAInt32(d);
 }  
   
 jsdouble FASTCALL  
 js_ParseFloat(JSContext* cx, JSString* str)  
 {  
     const jschar* bp;  
     const jschar* end;  
     const jschar* ep;  
     jsdouble d;  
   
     JSSTRING_CHARS_AND_END(str, bp, end);  
     if (!js_strtod(cx, bp, end, &ep, &d) || ep == bp)  
         return js_NaN;  
     return d;  
 }  
   
 jsdouble FASTCALL  
 js_ParseInt(JSContext* cx, JSString* str)  
 {  
     const jschar* bp;  
     const jschar* end;  
     const jschar* ep;  
     jsdouble d;  
   
     JSSTRING_CHARS_AND_END(str, bp, end);  
     if (!js_strtointeger(cx, bp, end, &ep, 0, &d) || ep == bp)  
         return js_NaN;  
     return d;  
188  }  }
189    
190  jsdouble FASTCALL  static inline JSBool
191  js_ParseIntDouble(jsdouble d)  js_Int32ToId(JSContext* cx, int32 index, jsid* id)
192  {  {
193      if (!JSDOUBLE_IS_FINITE(d))      if (index <= JSVAL_INT_MAX) {
194          return js_NaN;          *id = INT_TO_JSID(index);
195      return floor(d);          return JS_TRUE;
196        }
197        JSString* str = js_NumberToString(cx, index);
198        if (!str)
199            return JS_FALSE;
200        return js_ValueToStringId(cx, STRING_TO_JSVAL(str), id);
201  }  }
202    
203  jsval FASTCALL  jsval FASTCALL
# Line 514  Line 223 
223  }  }
224    
225  jsval FASTCALL  jsval FASTCALL
226  js_Any_getelem(JSContext* cx, JSObject* obj, jsint index)  js_Any_getelem(JSContext* cx, JSObject* obj, int32 index)
227  {  {
228      jsval v;      jsval v;
229      jsid id;      jsid id;
230      if (index < 0)      if (!js_Int32ToId(cx, index, &id))
         return JSVAL_ERROR_COOKIE;  
     if (!js_IndexToId(cx, index, &id))  
231          return JSVAL_ERROR_COOKIE;          return JSVAL_ERROR_COOKIE;
232      if (!OBJ_GET_PROPERTY(cx, obj, id, &v))      if (!OBJ_GET_PROPERTY(cx, obj, id, &v))
233          return JSVAL_ERROR_COOKIE;          return JSVAL_ERROR_COOKIE;
# Line 528  Line 235 
235  }  }
236    
237  JSBool FASTCALL  JSBool FASTCALL
238  js_Any_setelem(JSContext* cx, JSObject* obj, jsint index, jsval v)  js_Any_setelem(JSContext* cx, JSObject* obj, int32 index, jsval v)
239  {  {
240      jsid id;      jsid id;
241      if (index < 0)      if (!js_Int32ToId(cx, index, &id))
242          return JSVAL_ERROR_COOKIE;          return JSVAL_ERROR_COOKIE;
     if (!js_IndexToId(cx, index, &id))  
         return JS_FALSE;  
243      return OBJ_SET_PROPERTY(cx, obj, id, &v);      return OBJ_SET_PROPERTY(cx, obj, id, &v);
244  }  }
245    
# Line 555  Line 260 
260      return v;      return v;
261  }  }
262    
263  GuardRecord* FASTCALL  SideExit* FASTCALL
264  js_CallTree(InterpState* state, Fragment* f)  js_CallTree(InterpState* state, Fragment* f)
265  {  {
     GuardRecord* lr;  
266      union { NIns *code; GuardRecord* (FASTCALL *func)(InterpState*, Fragment*); } u;      union { NIns *code; GuardRecord* (FASTCALL *func)(InterpState*, Fragment*); } u;
267    
268      u.code = f->code();      u.code = f->code();
269      JS_ASSERT(u.code);      JS_ASSERT(u.code);
270    
271        GuardRecord* rec;
272  #if defined(JS_NO_FASTCALL) && defined(NANOJIT_IA32)  #if defined(JS_NO_FASTCALL) && defined(NANOJIT_IA32)
273      SIMULATE_FASTCALL(lr, state, NULL, u.func);      SIMULATE_FASTCALL(rec, state, NULL, u.func);
274  #else  #else
275      lr = u.func(state, NULL);      rec = u.func(state, NULL);
276  #endif  #endif
277        VMSideExit* lr = (VMSideExit*)rec->exit;
278    
279      if (lr->exit->exitType == NESTED_EXIT) {      if (lr->exitType == NESTED_EXIT) {
280          /* This only occurs once a tree call guard mismatches and we unwind the tree call stack.          /* This only occurs once a tree call guard mismatches and we unwind the tree call stack.
281             We store the first (innermost) tree call guard in state and we will try to grow             We store the first (innermost) tree call guard in state and we will try to grow
282             the outer tree the failing call was in starting at that guard. */             the outer tree the failing call was in starting at that guard. */
283          if (!state->lastTreeCallGuard)          if (!state->lastTreeCallGuard) {
284              state->lastTreeCallGuard = lr;              state->lastTreeCallGuard = lr;
285                FrameInfo* rp = (FrameInfo*)state->rp;
286                state->rpAtLastTreeCall = rp + lr->calldepth;
287            }
288      } else {      } else {
289          /* If the tree exits on a regular (non-nested) guard, keep updating lastTreeExitGuard          /* If the tree exits on a regular (non-nested) guard, keep updating lastTreeExitGuard
290             with that guard. If we mismatch on a tree call guard, this will contain the last             with that guard. If we mismatch on a tree call guard, this will contain the last
# Line 586  Line 295 
295      return lr;      return lr;
296  }  }
297    
 JS_STATIC_ASSERT(JSSLOT_PRIVATE == JSSLOT_ARRAY_LENGTH);  
 JS_STATIC_ASSERT(JSSLOT_ARRAY_LENGTH + 1 == JSSLOT_ARRAY_COUNT);  
   
 JSObject* FASTCALL  
 js_FastNewArray(JSContext* cx, JSObject* proto)  
 {  
     JS_ASSERT(OBJ_IS_ARRAY(cx, proto));  
   
     JS_ASSERT(JS_ON_TRACE(cx));  
     JSObject* obj = (JSObject*) js_NewGCThing(cx, GCX_OBJECT, sizeof(JSObject));  
     if (!obj)  
         return NULL;  
   
     JSClass* clasp = &js_ArrayClass;  
     obj->classword = jsuword(clasp);  
   
     obj->fslots[JSSLOT_PROTO] = OBJECT_TO_JSVAL(proto);  
     obj->fslots[JSSLOT_PARENT] = proto->fslots[JSSLOT_PARENT];  
   
     obj->fslots[JSSLOT_ARRAY_LENGTH] = 0;  
     obj->fslots[JSSLOT_ARRAY_COUNT] = 0;  
     for (unsigned i = JSSLOT_ARRAY_COUNT + 1; i != JS_INITIAL_NSLOTS; ++i)  
         obj->fslots[i] = JSVAL_VOID;  
   
     JSObjectOps* ops = clasp->getObjectOps(cx, clasp);  
     obj->map = ops->newObjectMap(cx, 1, ops, clasp, obj);  
     if (!obj->map)  
         return NULL;  
     obj->dslots = NULL;  
     return obj;  
 }  
   
298  JSObject* FASTCALL  JSObject* FASTCALL
299  js_FastNewObject(JSContext* cx, JSObject* ctor)  js_FastNewObject(JSContext* cx, JSObject* ctor)
300  {  {
301      JS_ASSERT(HAS_FUNCTION_CLASS(ctor));      JS_ASSERT(HAS_FUNCTION_CLASS(ctor));
302      JSFunction* fun = GET_FUNCTION_PRIVATE(cx, ctor);      JSFunction* fun = GET_FUNCTION_PRIVATE(cx, ctor);
303      JSClass* clasp = FUN_INTERPRETED(fun) ? &js_ObjectClass : fun->u.n.clasp;      JSClass* clasp = (FUN_INTERPRETED(fun) || (fun->flags & JSFUN_TRACEABLE))
304                         ? &js_ObjectClass
305                         : FUN_CLASP(fun);
306      JS_ASSERT(clasp != &js_ArrayClass);      JS_ASSERT(clasp != &js_ArrayClass);
307    
308      JS_LOCK_OBJ(cx, ctor);      JS_LOCK_OBJ(cx, ctor);
# Line 723  Line 402 
402  js_HasNamedProperty(JSContext* cx, JSObject* obj, JSString* idstr)  js_HasNamedProperty(JSContext* cx, JSObject* obj, JSString* idstr)
403  {  {
404      jsid id;      jsid id;
405      if (!js_ValueToStringId(cx, STRING_TO_JSVAL(idstr), &id))      if (!obj || !js_ValueToStringId(cx, STRING_TO_JSVAL(idstr), &id))
406          return JS_FALSE;          return JSVAL_TO_BOOLEAN(JSVAL_VOID);
407    
408        JSObject* obj2;
409        JSProperty* prop;
410        if (!OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop))
411            return JSVAL_TO_BOOLEAN(JSVAL_VOID);
412        if (prop)
413            OBJ_DROP_PROPERTY(cx, obj2, prop);
414        return prop != NULL;
415    }
416    
417    JSBool FASTCALL
418    js_HasNamedPropertyInt32(JSContext* cx, JSObject* obj, int32 index)
419    {
420        jsid id;
421        if (!obj || !js_Int32ToId(cx, index, &id))
422            return JSVAL_TO_BOOLEAN(JSVAL_VOID);
423    
424      JSObject* obj2;      JSObject* obj2;
425      JSProperty* prop;      JSProperty* prop;
# Line 753  Line 448 
448  }  }
449    
450  JSString* FASTCALL  JSString* FASTCALL
451  js_TypeOfBoolean(JSContext* cx, jsint unboxed)  js_TypeOfBoolean(JSContext* cx, int32 unboxed)
452  {  {
453      jsval boxed = BOOLEAN_TO_JSVAL(unboxed);      jsval boxed = BOOLEAN_TO_JSVAL(unboxed);
454      JS_ASSERT(JSVAL_IS_VOID(boxed) || JSVAL_IS_BOOLEAN(boxed));      JS_ASSERT(JSVAL_IS_VOID(boxed) || JSVAL_IS_BOOLEAN(boxed));
# Line 761  Line 456 
456      return ATOM_TO_STRING(cx->runtime->atomState.typeAtoms[type]);      return ATOM_TO_STRING(cx->runtime->atomState.typeAtoms[type]);
457  }  }
458    
 jsint FASTCALL  
 js_Object_p_hasOwnProperty(JSContext* cx, JSObject* obj, JSString *str)  
 {  
     jsid id = ATOM_TO_JSID(STRING_TO_JSVAL(str));  
     jsval v;  
     if (!js_HasOwnProperty(cx, obj->map->ops->lookupProperty, obj, id, &v))  
         return JSVAL_TO_BOOLEAN(JSVAL_VOID);  
     JS_ASSERT(JSVAL_IS_BOOLEAN(v));  
     return JSVAL_TO_BOOLEAN(v);  
 }  
   
 jsint FASTCALL  
 js_Object_p_propertyIsEnumerable(JSContext* cx, JSObject* obj, JSString *str)  
 {  
     jsid id = ATOM_TO_JSID(STRING_TO_JSVAL(str));  
     jsval v;  
     if (!js_PropertyIsEnumerable(cx, obj, id, &v))  
         return JSVAL_TO_BOOLEAN(JSVAL_VOID);  
     JS_ASSERT(JSVAL_IS_BOOLEAN(v));  
     return JSVAL_TO_BOOLEAN(v);  
 }  
   
459  jsdouble FASTCALL  jsdouble FASTCALL
460  js_BooleanToNumber(JSContext* cx, jsint unboxed)  js_BooleanOrUndefinedToNumber(JSContext* cx, int32 unboxed)
461  {  {
462      if (unboxed == JSVAL_TO_BOOLEAN(JSVAL_VOID))      if (unboxed == JSVAL_TO_BOOLEAN(JSVAL_VOID))
463          return js_NaN;          return js_NaN;
# Line 792  Line 465 
465  }  }
466    
467  JSString* FASTCALL  JSString* FASTCALL
468    js_BooleanOrUndefinedToString(JSContext *cx, int32 unboxed)
469    {
470        JS_ASSERT(uint32(unboxed) <= 2);
471        return ATOM_TO_STRING(cx->runtime->atomState.booleanAtoms[unboxed]);
472    }
473    
474    JSString* FASTCALL
475  js_ObjectToString(JSContext* cx, JSObject* obj)  js_ObjectToString(JSContext* cx, JSObject* obj)
476  {  {
477      if (!obj)      if (!obj)
# Line 804  Line 484 
484  }  }
485    
486  JSObject* FASTCALL  JSObject* FASTCALL
 js_Array_1int(JSContext* cx, JSObject* proto, jsint i)  
 {  
     JS_ASSERT(JS_ON_TRACE(cx));  
     JSObject* obj = js_FastNewArray(cx, proto);  
     if (obj)  
         obj->fslots[JSSLOT_ARRAY_LENGTH] = i;  
     return obj;  
 }  
   
 #define ARRAY_CTOR_GUTS(exact_len, newslots_code)                             \  
     JS_ASSERT(JS_ON_TRACE(cx));                                               \  
     JSObject* obj = js_FastNewArray(cx, proto);                               \  
     if (obj) {                                                                \  
         const uint32 len = ARRAY_GROWBY;                                      \  
         jsval* newslots = (jsval*) JS_malloc(cx, sizeof (jsval) * (len + 1)); \  
         if (newslots) {                                                       \  
             obj->dslots = newslots + 1;                                       \  
             ARRAY_SET_DENSE_LENGTH(obj, len);                                 \  
             {newslots_code}                                                   \  
             while (++newslots < obj->dslots + len)                            \  
                 *newslots = JSVAL_HOLE;                                       \  
             obj->fslots[JSSLOT_ARRAY_LENGTH] = (exact_len);                   \  
             return obj;                                                       \  
         }                                                                     \  
     }                                                                         \  
     return NULL;  
   
 JSObject* FASTCALL  
 js_Array_1str(JSContext* cx, JSObject* proto, JSString *str)  
 {  
     ARRAY_CTOR_GUTS(1, *++newslots = STRING_TO_JSVAL(str);)  
 }  
   
 JSObject* FASTCALL  
 js_Array_2obj(JSContext* cx, JSObject* proto, JSObject *obj1, JSObject* obj2)  
 {  
     ARRAY_CTOR_GUTS(2,  
         *++newslots = OBJECT_TO_JSVAL(obj1);  
         *++newslots = OBJECT_TO_JSVAL(obj2);)  
 }  
   
 JSObject* FASTCALL  
 js_Array_3num(JSContext* cx, JSObject* proto, jsdouble n1, jsdouble n2, jsdouble n3)  
 {  
     ARRAY_CTOR_GUTS(3,  
         if (!js_NewDoubleInRootedValue(cx, n1, ++newslots))  
             return NULL;  
         if (!js_NewDoubleInRootedValue(cx, n2, ++newslots))  
             return NULL;  
         if (!js_NewDoubleInRootedValue(cx, n3, ++newslots))  
             return NULL;)  
 }  
   
 JSObject* FASTCALL  
487  js_Arguments(JSContext* cx)  js_Arguments(JSContext* cx)
488  {  {
489      return NULL;      return NULL;
490  }  }
491    
492  jsdouble FASTCALL  #define BUILTIN1 JS_DEFINE_CALLINFO_1
493  js_Date_now(JSContext*)  #define BUILTIN2 JS_DEFINE_CALLINFO_2
494  {  #define BUILTIN3 JS_DEFINE_CALLINFO_3
495      return PRMJ_Now() / PRMJ_USEC_PER_MSEC;  #define BUILTIN4 JS_DEFINE_CALLINFO_4
496  }  #define BUILTIN5 JS_DEFINE_CALLINFO_5
   
 /* soft float */  
   
 jsdouble FASTCALL  
 js_fneg(jsdouble x)  
 {  
     return -x;  
 }  
   
 jsdouble FASTCALL  
 js_i2f(jsint i)  
 {  
     return i;  
 }  
   
 jsdouble FASTCALL  
 js_u2f(jsuint u)  
 {  
     return u;  
 }  
   
 jsint FASTCALL  
 js_fcmpeq(jsdouble x, jsdouble y)  
 {  
     return x==y;  
 }  
   
 jsint FASTCALL  
 js_fcmplt(jsdouble x, jsdouble y)  
 {  
     return x < y;  
 }  
   
 jsint FASTCALL  
 js_fcmple(jsdouble x, jsdouble y)  
 {  
     return x <= y;  
 }  
   
 jsint FASTCALL  
 js_fcmpgt(jsdouble x, jsdouble y)  
 {  
     return x > y;  
 }  
   
 jsint FASTCALL  
 js_fcmpge(jsdouble x, jsdouble y)  
 {  
     return x >= y;  
 }  
   
 jsdouble FASTCALL  
 js_fmul(jsdouble x, jsdouble y)  
 {  
     return x * y;  
 }  
 jsdouble FASTCALL  
 js_fadd(jsdouble x, jsdouble y)  
 {  
     return x + y;  
 }  
   
 jsdouble FASTCALL  
 js_fdiv(jsdouble x, jsdouble y)  
 {  
     return x / y;  
 }  
   
 jsdouble FASTCALL  
 js_fsub(jsdouble x, jsdouble y)  
 {  
     return x - y;  
 }  
   
 #define LO ARGSIZE_LO  
 #define F  ARGSIZE_F  
 #define Q  ARGSIZE_Q  
   
 #if defined AVMPLUS_64BIT  
 #define P       ARGSIZE_Q  
 #else  
 #define P       ARGSIZE_LO  
 #endif  
   
 #ifdef DEBUG  
 #define NAME(op) ,#op  
 #else  
 #define NAME(op)  
 #endif  
   
 #define BUILTIN1(op, at0, atr, tr, t0, cse, fold) \  
     { (intptr_t)&js_##op, (at0 << 2) | atr, cse, fold NAME(op) },  
 #define BUILTIN2(op, at0, at1, atr, tr, t0, t1, cse, fold) \  
     { (intptr_t)&js_##op, (at0 << 4) | (at1 << 2) | atr, cse, fold NAME(op) },  
 #define BUILTIN3(op, at0, at1, at2, atr, tr, t0, t1, t2, cse, fold) \  
     { (intptr_t)&js_##op, (at0 << 6) | (at1 << 4) | (at2 << 2) | atr, cse, fold NAME(op) },  
 #define BUILTIN4(op, at0, at1, at2, at3, atr, tr, t0, t1, t2, t3, cse, fold) \  
     { (intptr_t)&js_##op, (at0 << 8) | (at1 << 6) | (at2 << 4) | (at3 << 2) | atr, cse, fold NAME(op) },  
 #define BUILTIN5(op, at0, at1, at2, at3, at4, atr, tr, t0, t1, t2, t3, t4, cse, fold) \  
     { (intptr_t)&js_##op, (at0 << 10) | (at1 << 8) | (at2 << 6) | (at3 << 4) | (at4 << 2) | atr, cse, fold NAME(op) },  
   
 struct CallInfo builtins[] = {  
497  #include "builtins.tbl"  #include "builtins.tbl"
 };  

Legend:
Removed from v.332  
changed lines
  Added in v.399

  ViewVC Help
Powered by ViewVC 1.1.24