/[jscoverage]/trunk/js/jsscope.h
ViewVC logotype

Diff of /trunk/js/jsscope.h

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

revision 460 by siliconforks, Sat Sep 26 23:15:22 2009 UTC revision 507 by siliconforks, Sun Jan 10 07:23:34 2010 UTC
# Line 195  Line 195 
195   * to find a given id, and save on the space overhead of a hash table.   * to find a given id, and save on the space overhead of a hash table.
196   */   */
197    
198  struct JSScope {  struct JSEmptyScope;
199      JSObjectMap     map;                /* base class state */  
200    struct JSScope : public JSObjectMap
201    {
202  #ifdef JS_THREADSAFE  #ifdef JS_THREADSAFE
203      JSTitle         title;              /* lock state */      JSTitle         title;              /* lock state */
204  #endif  #endif
205      JSObject        *object;            /* object that owns this scope */      JSObject        *object;            /* object that owns this scope */
206      jsrefcount      nrefs;              /* count of all referencing objects */      jsrefcount      nrefs;              /* count of all referencing objects */
207      uint32          freeslot;           /* index of next free slot in object */      uint32          freeslot;           /* index of next free slot in object */
208      uint32          shape;              /* property cache shape identifier */      JSEmptyScope    *emptyScope;        /* cache for getEmptyScope below */
209      uint8           flags;              /* flags, see below */      uint8           flags;              /* flags, see below */
210      int8            hashShift;          /* multiplicative hash shift */      int8            hashShift;          /* multiplicative hash shift */
211    
212      uint16          spare;              /* reserved */      uint16          spare;              /* reserved */
213      uint32          entryCount;         /* number of entries in table */      uint32          entryCount;         /* number of entries in table */
214      uint32          removedCount;       /* removed entry sentinels in table */      uint32          removedCount;       /* removed entry sentinels in table */
215      JSScopeProperty **table;            /* table of ptrs to shared tree nodes */      JSScopeProperty **table;            /* table of ptrs to shared tree nodes */
216      JSScopeProperty *lastProp;          /* pointer to last property added */      JSScopeProperty *lastProp;          /* pointer to last property added */
 };  
217    
218  #define JS_IS_SCOPE_LOCKED(cx, scope)   JS_IS_TITLE_LOCKED(cx, &(scope)->title)    private:
219        void initMinimal(JSContext *cx, uint32 newShape);
220        bool createTable(JSContext *cx, bool report);
221        bool changeTable(JSContext *cx, int change);
222        void reportReadOnlyScope(JSContext *cx);
223        void generateOwnShape(JSContext *cx);
224        JSScopeProperty **searchTable(jsid id, bool adding);
225        inline JSScopeProperty **search(jsid id, bool adding);
226        JSEmptyScope *createEmptyScope(JSContext *cx, JSClass *clasp);
227    
228      public:
229        explicit JSScope(const JSObjectOps *ops, JSObject *obj = NULL)
230          : JSObjectMap(ops, 0), object(obj) {}
231    
232        /* Create a mutable, owned, empty scope. */
233        static JSScope *create(JSContext *cx, const JSObjectOps *ops, JSClass *clasp,
234                               JSObject *obj, uint32 shape);
235    
236        static void destroy(JSContext *cx, JSScope *scope);
237    
238        inline void hold();
239        inline bool drop(JSContext *cx, JSObject *obj);
240    
241        /*
242         * Return an immutable, shareable, empty scope with the same ops as this
243         * and the same freeslot as this had when empty.
244         *
245         * If |this| is the scope of an object |proto|, the resulting scope can be
246         * used as the scope of a new object whose prototype is |proto|.
247         */
248        inline JSEmptyScope *getEmptyScope(JSContext *cx, JSClass *clasp);
249    
250        inline bool canProvideEmptyScope(JSObjectOps *ops, JSClass *clasp);
251    
252        JSScopeProperty *lookup(jsid id);
253        bool has(JSScopeProperty *sprop);
254    
255        JSScopeProperty *add(JSContext *cx, jsid id,
256                             JSPropertyOp getter, JSPropertyOp setter,
257                             uint32 slot, uintN attrs,
258                             uintN flags, intN shortid);
259    
260        JSScopeProperty *change(JSContext *cx, JSScopeProperty *sprop,
261                                uintN attrs, uintN mask,
262                                JSPropertyOp getter, JSPropertyOp setter);
263    
264        bool remove(JSContext *cx, jsid id);
265        void clear(JSContext *cx);
266    
267  #define OBJ_SCOPE(obj)                  (JS_ASSERT(OBJ_IS_NATIVE(obj)),       \      void extend(JSContext *cx, JSScopeProperty *sprop);
268                                           (JSScope *) (obj)->map)  
269  #define OBJ_SHAPE(obj)                  (OBJ_SCOPE(obj)->shape)      void trace(JSTracer *trc);
270    
271        void brandingShapeChange(JSContext *cx, uint32 slot, jsval v);
272        void deletingShapeChange(JSContext *cx, JSScopeProperty *sprop);
273        void methodShapeChange(JSContext *cx, uint32 slot, jsval toval);
274        void protoShapeChange(JSContext *cx);
275        void replacingShapeChange(JSContext *cx,
276                                  JSScopeProperty *sprop,
277                                  JSScopeProperty *newsprop);
278        void sealingShapeChange(JSContext *cx);
279        void shadowingShapeChange(JSContext *cx, JSScopeProperty *sprop);
280    
281  /* By definition, hashShift = JS_DHASH_BITS - log2(capacity). */  /* By definition, hashShift = JS_DHASH_BITS - log2(capacity). */
282  #define SCOPE_CAPACITY(scope)           JS_BIT(JS_DHASH_BITS-(scope)->hashShift)  #define SCOPE_CAPACITY(scope)           JS_BIT(JS_DHASH_BITS-(scope)->hashShift)
283    
284  /* Scope flags and some macros to hide them from other files than jsscope.c. */      enum {
285  #define SCOPE_MIDDLE_DELETE             0x0001          MIDDLE_DELETE           = 0x0001,
286  #define SCOPE_SEALED                    0x0002          SEALED                  = 0x0002,
287  #define SCOPE_BRANDED                   0x0004          BRANDED                 = 0x0004,
288  #define SCOPE_INDEXED_PROPERTIES        0x0008          INDEXED_PROPERTIES      = 0x0008,
289            OWN_SHAPE               = 0x0010,
290  #define SCOPE_HAD_MIDDLE_DELETE(scope)  ((scope)->flags & SCOPE_MIDDLE_DELETE)  
291  #define SCOPE_SET_MIDDLE_DELETE(scope)  ((scope)->flags |= SCOPE_MIDDLE_DELETE)          /*
292  #define SCOPE_CLR_MIDDLE_DELETE(scope)  ((scope)->flags &= ~SCOPE_MIDDLE_DELETE)           * This flag toggles with each shape-regenerating GC cycle.
293  #define SCOPE_HAS_INDEXED_PROPERTIES(scope)  ((scope)->flags & SCOPE_INDEXED_PROPERTIES)           * See JSRuntime::gcRegenShapesScopeFlag.
294  #define SCOPE_SET_INDEXED_PROPERTIES(scope)  ((scope)->flags |= SCOPE_INDEXED_PROPERTIES)           */
295            SHAPE_REGEN             = 0x0020
296  #define SCOPE_IS_SEALED(scope)          ((scope)->flags & SCOPE_SEALED)      };
297  #define SCOPE_SET_SEALED(scope)         ((scope)->flags |= SCOPE_SEALED)  
298  #if 0      bool hadMiddleDelete()      { return flags & MIDDLE_DELETE; }
299  /*      void setMiddleDelete()      { flags |= MIDDLE_DELETE; }
300   * Don't define this, it can't be done safely because JS_LOCK_OBJ will avoid      void clearMiddleDelete()    { flags &= ~MIDDLE_DELETE; }
  * taking the lock if the object owns its scope and the scope is sealed.  
  */  
 #undef  SCOPE_CLR_SEALED(scope)         ((scope)->flags &= ~SCOPE_SEALED)  
 #endif  
301    
302  /*      /*
303   * A branded scope's object contains plain old methods (function-valued       * Don't define clearSealed, as it can't be done safely because JS_LOCK_OBJ
304   * properties without magic getters and setters), and its scope->shape       * will avoid taking the lock if the object owns its scope and the scope is
305   * evolves whenever a function value changes.       * sealed.
306   */       */
307  #define SCOPE_IS_BRANDED(scope)         ((scope)->flags & SCOPE_BRANDED)      bool sealed()               { return flags & SEALED; }
308  #define SCOPE_SET_BRANDED(scope)        ((scope)->flags |= SCOPE_BRANDED)      void setSealed()            { flags |= SEALED; }
309  #define SCOPE_CLR_BRANDED(scope)        ((scope)->flags &= ~SCOPE_BRANDED)  
310        /*
311         * A branded scope's object contains plain old methods (function-valued
312         * properties without magic getters and setters), and its scope->shape
313         * evolves whenever a function value changes.
314         */
315        bool branded()              { return flags & BRANDED; }
316        void setBranded()           { flags |= BRANDED; }
317    
318        bool hadIndexedProperties() { return flags & INDEXED_PROPERTIES; }
319        void setIndexedProperties() { flags |= INDEXED_PROPERTIES; }
320    
321        bool hasOwnShape()          { return flags & OWN_SHAPE; }
322        void setOwnShape()          { flags |= OWN_SHAPE; }
323    
324        bool hasRegenFlag(uint8 regenFlag) { return (flags & SHAPE_REGEN) == regenFlag; }
325    
326        bool owned()                { return object != NULL; }
327    };
328    
329    struct JSEmptyScope : public JSScope
330    {
331        JSClass * const clasp;
332    
333        explicit JSEmptyScope(const JSObjectOps *ops, JSClass *clasp)
334          : JSScope(ops), clasp(clasp) {}
335    };
336    
337    inline bool
338    JS_IS_SCOPE_LOCKED(JSContext *cx, JSScope *scope)
339    {
340        return JS_IS_TITLE_LOCKED(cx, &scope->title);
341    }
342    
343    inline JSScope *
344    OBJ_SCOPE(JSObject *obj)
345    {
346        JS_ASSERT(OBJ_IS_NATIVE(obj));
347        return (JSScope *) obj->map;
348    }
349    
350    inline uint32
351    OBJ_SHAPE(JSObject *obj)
352    {
353        JS_ASSERT(obj->map->shape != JSObjectMap::SHAPELESS);
354        return obj->map->shape;
355    }
356    
357  /*  /*
358   * A little information hiding for scope->lastProp, in case it ever becomes   * A little information hiding for scope->lastProp, in case it ever becomes
# Line 264  Line 365 
365   * Helpers for reinterpreting JSPropertyOp as JSObject* for scripted getters   * Helpers for reinterpreting JSPropertyOp as JSObject* for scripted getters
366   * and setters.   * and setters.
367   */   */
368  static inline JSObject *  inline JSObject *
369  js_CastAsObject(JSPropertyOp op)  js_CastAsObject(JSPropertyOp op)
370  {  {
371      return JS_FUNC_TO_DATA_PTR(JSObject *, op);      return JS_FUNC_TO_DATA_PTR(JSObject *, op);
372  }  }
373    
374  static inline jsval  inline jsval
375  js_CastAsObjectJSVal(JSPropertyOp op)  js_CastAsObjectJSVal(JSPropertyOp op)
376  {  {
377      return OBJECT_TO_JSVAL(JS_FUNC_TO_DATA_PTR(JSObject *, op));      return OBJECT_TO_JSVAL(JS_FUNC_TO_DATA_PTR(JSObject *, op));
378  }  }
379    
380  static inline JSPropertyOp  inline JSPropertyOp
381  js_CastAsPropertyOp(JSObject *object)  js_CastAsPropertyOp(JSObject *object)
382  {  {
383      return JS_DATA_TO_FUNC_PTR(JSPropertyOp, object);      return JS_DATA_TO_FUNC_PTR(JSPropertyOp, object);
# Line 294  Line 395 
395      JSScopeProperty *kids;              /* null, single child, or a tagged ptr      JSScopeProperty *kids;              /* null, single child, or a tagged ptr
396                                             to many-kids data structure */                                             to many-kids data structure */
397      uint32          shape;              /* property cache shape identifier */      uint32          shape;              /* property cache shape identifier */
398    
399        void trace(JSTracer *trc);
400  };  };
401    
402  /* JSScopeProperty pointer tag bit indicating a collision. */  /* JSScopeProperty pointer tag bit indicating a collision. */
# Line 316  Line 419 
419      (*(spp) = (JSScopeProperty *) ((jsuword)(sprop)                           \      (*(spp) = (JSScopeProperty *) ((jsuword)(sprop)                           \
420                                     | SPROP_HAD_COLLISION(*(spp))))                                     | SPROP_HAD_COLLISION(*(spp))))
421    
422    JS_ALWAYS_INLINE JSScopeProperty *
423    JSScope::lookup(jsid id)
424    {
425        return SPROP_FETCH(search(id, false));
426    }
427    
428    JS_ALWAYS_INLINE bool
429    JSScope::has(JSScopeProperty *sprop)
430    {
431        return lookup(sprop->id) == sprop;
432    }
433    
434  /* Bits stored in sprop->flags. */  /* Bits stored in sprop->flags. */
435  #define SPROP_MARK                      0x01  #define SPROP_MARK                      0x01
436  #define SPROP_IS_ALIAS                  0x02  #define SPROP_IS_ALIAS                  0x02
# Line 338  Line 453 
453  #define SPROP_HAS_STUB_GETTER(sprop)    (!(sprop)->getter)  #define SPROP_HAS_STUB_GETTER(sprop)    (!(sprop)->getter)
454  #define SPROP_HAS_STUB_SETTER(sprop)    (!(sprop)->setter)  #define SPROP_HAS_STUB_SETTER(sprop)    (!(sprop)->setter)
455    
456  static inline void  #ifndef JS_THREADSAFE
457  js_MakeScopeShapeUnique(JSContext *cx, JSScope *scope)  # define js_GenerateShape(cx, gcLocked)    js_GenerateShape (cx)
458    #endif
459    
460    extern uint32
461    js_GenerateShape(JSContext *cx, bool gcLocked);
462    
463    #ifdef JS_DUMP_PROPTREE_STATS
464    # define METER(x)       JS_ATOMIC_INCREMENT(&js_scope_stats.x)
465    #else
466    # define METER(x)       /* nothing */
467    #endif
468    
469    inline JSScopeProperty **
470    JSScope::search(jsid id, bool adding)
471    {
472        JSScopeProperty *sprop, **spp;
473    
474        METER(searches);
475        if (!table) {
476            /* Not enough properties to justify hashing: search from lastProp. */
477            JS_ASSERT(!hadMiddleDelete());
478            for (spp = &lastProp; (sprop = *spp); spp = &sprop->parent) {
479                if (sprop->id == id) {
480                    METER(hits);
481                    return spp;
482                }
483            }
484            METER(misses);
485            return spp;
486        }
487        return searchTable(id, adding);
488    }
489    
490    #undef METER
491    
492    inline bool
493    JSScope::canProvideEmptyScope(JSObjectOps *ops, JSClass *clasp)
494  {  {
495      js_LeaveTraceIfGlobalObject(cx, scope->object);      return this->ops == ops && (!emptyScope || emptyScope->clasp == clasp);
     scope->shape = js_GenerateShape(cx, JS_FALSE);  
496  }  }
497    
498  static inline void  inline JSEmptyScope *
499  js_ExtendScopeShape(JSContext *cx, JSScope *scope, JSScopeProperty *sprop)  JSScope::getEmptyScope(JSContext *cx, JSClass *clasp)
500  {  {
501      js_LeaveTraceIfGlobalObject(cx, scope->object);      if (emptyScope) {
502      if (!scope->lastProp ||          JS_ASSERT(clasp == emptyScope->clasp);
503          scope->shape == scope->lastProp->shape) {          emptyScope->hold();
504          scope->shape = sprop->shape;          return emptyScope;
505      } else {      }
506          scope->shape = js_GenerateShape(cx, JS_FALSE);      return createEmptyScope(cx, clasp);
507    }
508    
509    inline void
510    JSScope::hold()
511    {
512        JS_ASSERT(nrefs >= 0);
513        JS_ATOMIC_INCREMENT(&nrefs);
514    }
515    
516    inline bool
517    JSScope::drop(JSContext *cx, JSObject *obj)
518    {
519    #ifdef JS_THREADSAFE
520        /* We are called from only js_ShareWaitingTitles and js_FinalizeObject. */
521        JS_ASSERT(!obj || CX_THREAD_IS_RUNNING_GC(cx));
522    #endif
523        JS_ASSERT(nrefs > 0);
524        --nrefs;
525    
526        if (nrefs == 0) {
527            destroy(cx, this);
528            return false;
529        }
530        if (object == obj)
531            object = NULL;
532        return true;
533    }
534    
535    inline void
536    JSScope::extend(JSContext *cx, JSScopeProperty *sprop)
537    {
538        js_LeaveTraceIfGlobalObject(cx, object);
539        shape = (!lastProp || shape == lastProp->shape)
540                ? sprop->shape
541                : js_GenerateShape(cx, JS_FALSE);
542        ++entryCount;
543        lastProp = sprop;
544    }
545    
546    inline void
547    JSScope::trace(JSTracer *trc)
548    {
549        JSContext *cx = trc->context;
550        JSScopeProperty *sprop = lastProp;
551        uint8 regenFlag = cx->runtime->gcRegenShapesScopeFlag;
552        if (IS_GC_MARKING_TRACER(trc) && cx->runtime->gcRegenShapes && !hasRegenFlag(regenFlag)) {
553            /*
554             * Either this scope has its own shape, which must be regenerated, or
555             * it must have the same shape as lastProp.
556             */
557            uint32 newShape;
558    
559            if (sprop) {
560                if (!(sprop->flags & SPROP_FLAG_SHAPE_REGEN)) {
561                    sprop->shape = js_RegenerateShapeForGC(cx);
562                    sprop->flags |= SPROP_FLAG_SHAPE_REGEN;
563                }
564                newShape = sprop->shape;
565            }
566            if (!sprop || hasOwnShape()) {
567                newShape = js_RegenerateShapeForGC(cx);
568                JS_ASSERT_IF(sprop, newShape != sprop->shape);
569            }
570            shape = newShape;
571            flags ^= JSScope::SHAPE_REGEN;
572    
573            /* Also regenerate the shapes of empty scopes, in case they are not shared. */
574            for (JSScope *empty = emptyScope;
575                 empty && !empty->hasRegenFlag(regenFlag);
576                 empty = empty->emptyScope) {
577                empty->shape = js_RegenerateShapeForGC(cx);
578                empty->flags ^= JSScope::SHAPE_REGEN;
579            }
580        }
581        if (sprop) {
582            JS_ASSERT(has(sprop));
583    
584            /* Trace scope's property tree ancestor line. */
585            do {
586                if (hadMiddleDelete() && !has(sprop))
587                    continue;
588                sprop->trace(trc);
589            } while ((sprop = sprop->parent) != NULL);
590      }      }
591  }  }
592    
593  static JS_INLINE JSBool  
594    static JS_INLINE bool
595  js_GetSprop(JSContext* cx, JSScopeProperty* sprop, JSObject* obj, jsval* vp)  js_GetSprop(JSContext* cx, JSScopeProperty* sprop, JSObject* obj, jsval* vp)
596  {  {
597      JS_ASSERT(!SPROP_HAS_STUB_GETTER(sprop));      JS_ASSERT(!SPROP_HAS_STUB_GETTER(sprop));
598    
599      if (sprop->attrs & JSPROP_GETTER) {      if (sprop->attrs & JSPROP_GETTER) {
600          jsval fval = js_CastAsObjectJSVal(sprop->getter);          jsval fval = js_CastAsObjectJSVal(sprop->getter);
601          return js_InternalGetOrSet(cx, obj, sprop->id, fval, JSACC_READ,          return js_InternalGetOrSet(cx, obj, sprop->id, fval, JSACC_READ,
# Line 378  Line 613 
613      return sprop->getter(cx, obj, SPROP_USERID(sprop), vp);      return sprop->getter(cx, obj, SPROP_USERID(sprop), vp);
614  }  }
615    
616  static JS_INLINE JSBool  static JS_INLINE bool
617  js_SetSprop(JSContext* cx, JSScopeProperty* sprop, JSObject* obj, jsval* vp)  js_SetSprop(JSContext* cx, JSScopeProperty* sprop, JSObject* obj, jsval* vp)
618  {  {
619      JS_ASSERT(!(SPROP_HAS_STUB_SETTER(sprop) &&      JS_ASSERT(!(SPROP_HAS_STUB_SETTER(sprop) &&
# Line 401  Line 636 
636      return sprop->setter(cx, obj, SPROP_USERID(sprop), vp);      return sprop->setter(cx, obj, SPROP_USERID(sprop), vp);
637  }  }
638    
 /*  
  * NB: SPROP_SET must not be called if (SPROP_HAS_STUB_SETTER(sprop) &&  
  * !(sprop->attrs & JSPROP_GETTER)).  
  */  
 #define SPROP_SET(cx,sprop,obj,obj2,vp)                                       \  
     (((sprop)->attrs & JSPROP_SETTER)                                         \  
      ? js_InternalGetOrSet(cx, obj, (sprop)->id,                              \  
                            OBJECT_TO_JSVAL((JSObject *) (sprop)->setter),     \  
                            JSACC_WRITE, 1, vp, vp)                            \  
      : ((sprop)->attrs & JSPROP_GETTER)                                       \  
      ? (JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,                    \  
                              JSMSG_GETTER_ONLY, NULL), JS_FALSE)              \  
      : (sprop)->setter(cx, obj, SPROP_USERID(sprop), vp))  
   
639  /* Macro for common expression to test for shared permanent attributes. */  /* Macro for common expression to test for shared permanent attributes. */
640  #define SPROP_IS_SHARED_PERMANENT(sprop)                                      \  #define SPROP_IS_SHARED_PERMANENT(sprop)                                      \
641      ((~(sprop)->attrs & (JSPROP_SHARED | JSPROP_PERMANENT)) == 0)      ((~(sprop)->attrs & (JSPROP_SHARED | JSPROP_PERMANENT)) == 0)
# Line 422  Line 643 
643  extern JSScope *  extern JSScope *
644  js_GetMutableScope(JSContext *cx, JSObject *obj);  js_GetMutableScope(JSContext *cx, JSObject *obj);
645    
 extern JSScope *  
 js_NewScope(JSContext *cx, JSObjectOps *ops, JSClass *clasp, JSObject *obj);  
   
 extern void  
 js_DestroyScope(JSContext *cx, JSScope *scope);  
   
 extern void  
 js_HoldScope(JSScope *scope);  
   
 extern JSBool  
 js_DropScope(JSContext *cx, JSScope *scope, JSObject *obj);  
   
 extern JS_FRIEND_API(JSScopeProperty **)  
 js_SearchScope(JSScope *scope, jsid id, JSBool adding);  
   
 #define SCOPE_GET_PROPERTY(scope, id)                                         \  
     SPROP_FETCH(js_SearchScope(scope, id, JS_FALSE))  
   
 #define SCOPE_HAS_PROPERTY(scope, sprop)                                      \  
     (SCOPE_GET_PROPERTY(scope, (sprop)->id) == (sprop))  
   
 extern JSScopeProperty *  
 js_AddScopeProperty(JSContext *cx, JSScope *scope, jsid id,  
                     JSPropertyOp getter, JSPropertyOp setter, uint32 slot,  
                     uintN attrs, uintN flags, intN shortid);  
   
 extern JSScopeProperty *  
 js_ChangeScopePropertyAttrs(JSContext *cx, JSScope *scope,  
                             JSScopeProperty *sprop, uintN attrs, uintN mask,  
                             JSPropertyOp getter, JSPropertyOp setter);  
   
 extern JSBool  
 js_RemoveScopeProperty(JSContext *cx, JSScope *scope, jsid id);  
   
 extern void  
 js_ClearScope(JSContext *cx, JSScope *scope);  
   
 /*  
  * These macros used to inline short code sequences, but they grew over time.  
  * We retain them for internal backward compatibility, and in case one or both  
  * ever shrink to inline-able size.  
  */  
 #define TRACE_ID(trc, id)                js_TraceId(trc, id)  
 #define TRACE_SCOPE_PROPERTY(trc, sprop) js_TraceScopeProperty(trc, sprop)  
   
646  extern void  extern void
647  js_TraceId(JSTracer *trc, jsid id);  js_TraceId(JSTracer *trc, jsid id);
648    
649  extern void  extern void
 js_TraceScopeProperty(JSTracer *trc, JSScopeProperty *sprop);  
   
 extern void  
650  js_SweepScopeProperties(JSContext *cx);  js_SweepScopeProperties(JSContext *cx);
651    
652  extern JSBool  extern bool
653  js_InitPropertyTree(JSRuntime *rt);  js_InitPropertyTree(JSRuntime *rt);
654    
655  extern void  extern void

Legend:
Removed from v.460  
changed lines
  Added in v.507

  ViewVC Help
Powered by ViewVC 1.1.24