do-not-enforce-wrong-arm-flags
[platform/upstream/js.git] / js / src / jsobjinlines.h
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2  * vim: set ts=8 sw=4 et tw=99:
3  *
4  * ***** BEGIN LICENSE BLOCK *****
5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
6  *
7  * The contents of this file are subject to the Mozilla Public License Version
8  * 1.1 (the "License"); you may not use this file except in compliance with
9  * the License. You may obtain a copy of the License at
10  * http://www.mozilla.org/MPL/
11  *
12  * Software distributed under the License is distributed on an "AS IS" basis,
13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14  * for the specific language governing rights and limitations under the
15  * License.
16  *
17  * The Original Code is Mozilla Communicator client code, released
18  * March 31, 1998.
19  *
20  * The Initial Developer of the Original Code is
21  * Netscape Communications Corporation.
22  * Portions created by the Initial Developer are Copyright (C) 1998
23  * the Initial Developer. All Rights Reserved.
24  *
25  * Contributor(s):
26  *
27  * Alternatively, the contents of this file may be used under the terms of
28  * either of the GNU General Public License Version 2 or later (the "GPL"),
29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
30  * in which case the provisions of the GPL or the LGPL are applicable instead
31  * of those above. If you wish to allow use of your version of this file only
32  * under the terms of either the GPL or the LGPL, and not to allow others to
33  * use your version of this file under the terms of the MPL, indicate your
34  * decision by deleting the provisions above and replace them with the notice
35  * and other provisions required by the GPL or the LGPL. If you do not delete
36  * the provisions above, a recipient may use your version of this file under
37  * the terms of any one of the MPL, the GPL or the LGPL.
38  *
39  * ***** END LICENSE BLOCK ***** */
40
41 #ifndef jsobjinlines_h___
42 #define jsobjinlines_h___
43
44 #include <new>
45 #include "jsdate.h"
46 #include "jsfun.h"
47 #include "jsiter.h"
48 #include "jslock.h"
49 #include "jsobj.h"
50 #include "jsprobes.h"
51 #include "jspropertytree.h"
52 #include "jsproxy.h"
53 #include "jsscope.h"
54 #include "jsstaticcheck.h"
55 #include "jsxml.h"
56
57 /* Headers included for inline implementations used by this header. */
58 #include "jsbool.h"
59 #include "jscntxt.h"
60 #include "jsnum.h"
61 #include "jsscopeinlines.h"
62 #include "jsstr.h"
63
64 #include "jsfuninlines.h"
65 #include "jsgcinlines.h"
66 #include "jsprobes.h"
67
68 inline bool
69 JSObject::preventExtensions(JSContext *cx, js::AutoIdVector *props)
70 {
71     JS_ASSERT(isExtensible());
72
73     if (js::FixOp fix = getOps()->fix) {
74         bool success;
75         if (!fix(cx, this, &success, props))
76             return false;
77         if (!success) {
78             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CANT_CHANGE_EXTENSIBILITY);
79             return false;
80         }
81     } else {
82         if (!GetPropertyNames(cx, this, JSITER_HIDDEN | JSITER_OWNONLY, props))
83             return false;
84     }
85
86     if (isNative())
87         extensibleShapeChange(cx);
88
89     flags |= NOT_EXTENSIBLE;
90     return true;
91 }
92
93 inline bool
94 JSObject::brand(JSContext *cx)
95 {
96     JS_ASSERT(!generic());
97     JS_ASSERT(!branded());
98     JS_ASSERT(isNative());
99     generateOwnShape(cx);
100     if (js_IsPropertyCacheDisabled(cx))  // check for rt->shapeGen overflow
101         return false;
102     flags |= BRANDED;
103     return true;
104 }
105
106 inline bool
107 JSObject::unbrand(JSContext *cx)
108 {
109     JS_ASSERT(isNative());
110     if (branded()) {
111         generateOwnShape(cx);
112         if (js_IsPropertyCacheDisabled(cx))  // check for rt->shapeGen overflow
113             return false;
114         flags &= ~BRANDED;
115     }
116     setGeneric();
117     return true;
118 }
119
120 inline void
121 JSObject::syncSpecialEquality()
122 {
123     if (clasp->ext.equality)
124         flags |= JSObject::HAS_EQUALITY;
125 }
126
127 inline void
128 JSObject::finalize(JSContext *cx)
129 {
130     /* Cope with stillborn objects that have no map. */
131     if (!map)
132         return;
133
134     /* Finalize obj first, in case it needs map and slots. */
135     js::Class *clasp = getClass();
136     if (clasp->finalize)
137         clasp->finalize(cx, this);
138
139     js::Probes::finalizeObject(this);
140
141     finish(cx);
142 }
143
144 /*
145  * Property read barrier for deferred cloning of compiler-created function
146  * objects optimized as typically non-escaping, ad-hoc methods in obj.
147  */
148 inline const js::Shape *
149 JSObject::methodReadBarrier(JSContext *cx, const js::Shape &shape, js::Value *vp)
150 {
151     JS_ASSERT(canHaveMethodBarrier());
152     JS_ASSERT(hasMethodBarrier());
153     JS_ASSERT(nativeContains(shape));
154     JS_ASSERT(shape.isMethod());
155     JS_ASSERT(&shape.methodObject() == &vp->toObject());
156     JS_ASSERT(shape.writable());
157     JS_ASSERT(shape.slot != SHAPE_INVALID_SLOT);
158     JS_ASSERT(shape.hasDefaultSetter() || shape.setterOp() == js_watch_set);
159     JS_ASSERT(!isGlobal());  /* i.e. we are not changing the global shape */
160
161     JSObject *funobj = &vp->toObject();
162     JSFunction *fun = funobj->getFunctionPrivate();
163     JS_ASSERT(fun == funobj);
164     JS_ASSERT(FUN_NULL_CLOSURE(fun));
165
166     funobj = CloneFunctionObject(cx, fun, funobj->getParent());
167     if (!funobj)
168         return NULL;
169     funobj->setMethodObj(*this);
170
171     /*
172      * Replace the method property with an ordinary data property. This is
173      * equivalent to this->setProperty(cx, shape.id, vp) except that any
174      * watchpoint on the property is not triggered.
175      */
176     uint32 slot = shape.slot;
177     const js::Shape *newshape = methodShapeChange(cx, shape);
178     if (!newshape)
179         return NULL;
180     JS_ASSERT(!newshape->isMethod());
181     JS_ASSERT(newshape->slot == slot);
182     vp->setObject(*funobj);
183     nativeSetSlot(slot, *vp);
184
185 #ifdef DEBUG
186     if (cx->runtime->functionMeterFilename) {
187         JS_FUNCTION_METER(cx, mreadbarrier);
188
189         typedef JSRuntime::FunctionCountMap HM;
190         HM &h = cx->runtime->methodReadBarrierCountMap;
191         HM::AddPtr p = h.lookupForAdd(fun);
192         if (!p) {
193             h.add(p, fun, 1);
194         } else {
195             JS_ASSERT(p->key == fun);
196             ++p->value;
197         }
198     }
199 #endif
200     return newshape;
201 }
202
203 static JS_ALWAYS_INLINE bool
204 ChangesMethodValue(const js::Value &prev, const js::Value &v)
205 {
206     JSObject *prevObj;
207     return prev.isObject() && (prevObj = &prev.toObject())->isFunction() &&
208            (!v.isObject() || &v.toObject() != prevObj);
209 }
210
211 inline const js::Shape *
212 JSObject::methodWriteBarrier(JSContext *cx, const js::Shape &shape, const js::Value &v)
213 {
214     if (brandedOrHasMethodBarrier() && shape.slot != SHAPE_INVALID_SLOT) {
215         const js::Value &prev = nativeGetSlot(shape.slot);
216
217         if (ChangesMethodValue(prev, v)) {
218             JS_FUNCTION_METER(cx, mwritebarrier);
219             return methodShapeChange(cx, shape);
220         }
221     }
222     return &shape;
223 }
224
225 inline bool
226 JSObject::methodWriteBarrier(JSContext *cx, uint32 slot, const js::Value &v)
227 {
228     if (brandedOrHasMethodBarrier()) {
229         const js::Value &prev = nativeGetSlot(slot);
230
231         if (ChangesMethodValue(prev, v)) {
232             JS_FUNCTION_METER(cx, mwslotbarrier);
233             return methodShapeChange(cx, slot);
234         }
235     }
236     return true;
237 }
238
239 inline bool
240 JSObject::ensureClassReservedSlots(JSContext *cx)
241 {
242     return !nativeEmpty() || ensureClassReservedSlotsForEmptyObject(cx);
243 }
244
245 inline js::Value
246 JSObject::getReservedSlot(uintN index) const
247 {
248     return (index < numSlots()) ? getSlot(index) : js::UndefinedValue();
249 }
250
251 inline bool
252 JSObject::canHaveMethodBarrier() const
253 {
254     return isObject() || isFunction() || isPrimitive() || isDate();
255 }
256
257 inline bool
258 JSObject::isPrimitive() const
259 {
260     return isNumber() || isString() || isBoolean();
261 }
262
263 inline const js::Value &
264 JSObject::getPrimitiveThis() const
265 {
266     JS_ASSERT(isPrimitive());
267     return getSlot(JSSLOT_PRIMITIVE_THIS);
268 }
269
270 inline void
271 JSObject::setPrimitiveThis(const js::Value &pthis)
272 {
273     JS_ASSERT(isPrimitive());
274     setSlot(JSSLOT_PRIMITIVE_THIS, pthis);
275 }
276
277 inline /* gc::FinalizeKind */ unsigned
278 JSObject::finalizeKind() const
279 {
280     return js::gc::FinalizeKind(arena()->header()->thingKind);
281 }
282
283 inline size_t
284 JSObject::numFixedSlots() const
285 {
286     if (isFunction())
287         return JSObject::FUN_CLASS_RESERVED_SLOTS;
288     if (!hasSlotsArray())
289         return capacity;
290     return js::gc::GetGCKindSlots(js::gc::FinalizeKind(finalizeKind()));
291 }
292
293 inline size_t
294 JSObject::slotsAndStructSize(uint32 nslots) const
295 {
296     bool isFun = isFunction() && this == (JSObject*) getPrivate();
297
298     int ndslots = hasSlotsArray() ? nslots : 0;
299     int nfslots = isFun ? 0 : numFixedSlots();
300
301     return sizeof(js::Value) * (ndslots + nfslots)
302            + isFun ? sizeof(JSFunction) : sizeof(JSObject);
303 }
304
305 inline uint32
306 JSObject::getArrayLength() const
307 {
308     JS_ASSERT(isArray());
309     return (uint32)(size_t) getPrivate();
310 }
311
312 inline void
313 JSObject::setArrayLength(uint32 length)
314 {
315     JS_ASSERT(isArray());
316     setPrivate((void*) length);
317 }
318
319 inline uint32
320 JSObject::getDenseArrayCapacity()
321 {
322     JS_ASSERT(isDenseArray());
323     return numSlots();
324 }
325
326 inline js::Value*
327 JSObject::getDenseArrayElements()
328 {
329     JS_ASSERT(isDenseArray());
330     return getSlots();
331 }
332
333 inline const js::Value &
334 JSObject::getDenseArrayElement(uintN idx)
335 {
336     JS_ASSERT(isDenseArray());
337     return getSlot(idx);
338 }
339
340 inline js::Value *
341 JSObject::addressOfDenseArrayElement(uintN idx)
342 {
343     JS_ASSERT(isDenseArray());
344     return &getSlotRef(idx);
345 }
346
347 inline void
348 JSObject::setDenseArrayElement(uintN idx, const js::Value &val)
349 {
350     JS_ASSERT(isDenseArray());
351     setSlot(idx, val);
352 }
353
354 inline void
355 JSObject::shrinkDenseArrayElements(JSContext *cx, uintN cap)
356 {
357     JS_ASSERT(isDenseArray());
358     shrinkSlots(cx, cap);
359 }
360
361 inline void
362 JSObject::setArgsLength(uint32 argc)
363 {
364     JS_ASSERT(isArguments());
365     JS_ASSERT(argc <= JS_ARGS_LENGTH_MAX);
366     JS_ASSERT(UINT32_MAX > (uint64(argc) << ARGS_PACKED_BITS_COUNT));
367     getSlotRef(JSSLOT_ARGS_LENGTH).setInt32(argc << ARGS_PACKED_BITS_COUNT);
368     JS_ASSERT(!isArgsLengthOverridden());
369 }
370
371 inline uint32
372 JSObject::getArgsInitialLength() const
373 {
374     JS_ASSERT(isArguments());
375     uint32 argc = uint32(getSlot(JSSLOT_ARGS_LENGTH).toInt32()) >> ARGS_PACKED_BITS_COUNT;
376     JS_ASSERT(argc <= JS_ARGS_LENGTH_MAX);
377     return argc;
378 }
379
380 inline void
381 JSObject::setArgsLengthOverridden()
382 {
383     JS_ASSERT(isArguments());
384     getSlotRef(JSSLOT_ARGS_LENGTH).getInt32Ref() |= ARGS_LENGTH_OVERRIDDEN_BIT;
385 }
386
387 inline bool
388 JSObject::isArgsLengthOverridden() const
389 {
390     JS_ASSERT(isArguments());
391     const js::Value &v = getSlot(JSSLOT_ARGS_LENGTH);
392     return v.toInt32() & ARGS_LENGTH_OVERRIDDEN_BIT;
393 }
394
395 inline js::ArgumentsData *
396 JSObject::getArgsData() const
397 {
398     JS_ASSERT(isArguments());
399     return (js::ArgumentsData *) getSlot(JSSLOT_ARGS_DATA).toPrivate();
400 }
401
402 inline void
403 JSObject::setArgsData(js::ArgumentsData *data)
404 {
405     JS_ASSERT(isArguments());
406     getSlotRef(JSSLOT_ARGS_DATA).setPrivate(data);
407 }
408
409 inline const js::Value &
410 JSObject::getArgsCallee() const
411 {
412     return getArgsData()->callee;
413 }
414
415 inline void
416 JSObject::setArgsCallee(const js::Value &callee)
417 {
418     getArgsData()->callee = callee;
419 }
420
421 inline const js::Value &
422 JSObject::getArgsElement(uint32 i) const
423 {
424     JS_ASSERT(isArguments());
425     JS_ASSERT(i < getArgsInitialLength());
426     return getArgsData()->slots[i];
427 }
428
429 inline js::Value *
430 JSObject::getArgsElements() const
431 {
432     JS_ASSERT(isArguments());
433     return getArgsData()->slots;
434 }
435
436 inline js::Value *
437 JSObject::addressOfArgsElement(uint32 i)
438 {
439     JS_ASSERT(isArguments());
440     JS_ASSERT(i < getArgsInitialLength());
441     return &getArgsData()->slots[i];
442 }
443
444 inline void
445 JSObject::setArgsElement(uint32 i, const js::Value &v)
446 {
447     JS_ASSERT(isArguments());
448     JS_ASSERT(i < getArgsInitialLength());
449     getArgsData()->slots[i] = v;
450 }
451
452 inline bool
453 JSObject::callIsForEval() const
454 {
455     JS_ASSERT(isCall());
456     JS_ASSERT(getSlot(JSSLOT_CALL_CALLEE).isObjectOrNull());
457     JS_ASSERT_IF(getSlot(JSSLOT_CALL_CALLEE).isObject(),
458                  getSlot(JSSLOT_CALL_CALLEE).toObject().isFunction());
459     return getSlot(JSSLOT_CALL_CALLEE).isNull();
460 }
461
462 inline JSStackFrame *
463 JSObject::maybeCallObjStackFrame() const
464 {
465     JS_ASSERT(isCall());
466     return reinterpret_cast<JSStackFrame *>(getPrivate());
467 }
468
469 inline void
470 JSObject::setCallObjCallee(JSObject *callee)
471 {
472     JS_ASSERT(isCall());
473     JS_ASSERT_IF(callee, callee->isFunction());
474     return getSlotRef(JSSLOT_CALL_CALLEE).setObjectOrNull(callee);
475 }
476
477 inline JSObject *
478 JSObject::getCallObjCallee() const
479 {
480     JS_ASSERT(isCall());
481     return getSlot(JSSLOT_CALL_CALLEE).toObjectOrNull();
482 }
483
484 inline JSFunction *
485 JSObject::getCallObjCalleeFunction() const
486 {
487     JS_ASSERT(isCall());
488     return getSlot(JSSLOT_CALL_CALLEE).toObject().getFunctionPrivate();
489 }
490
491 inline const js::Value &
492 JSObject::getCallObjArguments() const
493 {
494     JS_ASSERT(isCall());
495     JS_ASSERT(!callIsForEval());
496     return getSlot(JSSLOT_CALL_ARGUMENTS);
497 }
498
499 inline void
500 JSObject::setCallObjArguments(const js::Value &v)
501 {
502     JS_ASSERT(isCall());
503     JS_ASSERT(!callIsForEval());
504     setSlot(JSSLOT_CALL_ARGUMENTS, v);
505 }
506
507 inline const js::Value &
508 JSObject::callObjArg(uintN i) const
509 {
510     JS_ASSERT(isCall());
511     JS_ASSERT(i < getCallObjCalleeFunction()->nargs);
512     return getSlot(JSObject::CALL_RESERVED_SLOTS + i);
513 }
514
515 inline js::Value &
516 JSObject::callObjArg(uintN i)
517 {
518     JS_ASSERT(isCall());
519     JS_ASSERT(i < getCallObjCalleeFunction()->nargs);
520     return getSlotRef(JSObject::CALL_RESERVED_SLOTS + i);
521 }
522
523 inline const js::Value &
524 JSObject::callObjVar(uintN i) const
525 {
526     JSFunction *fun = getCallObjCalleeFunction();
527     JS_ASSERT(fun->nargs == fun->script()->bindings.countArgs());
528     JS_ASSERT(i < fun->script()->bindings.countVars());
529     return getSlot(JSObject::CALL_RESERVED_SLOTS + fun->nargs + i);
530 }
531
532 inline js::Value &
533 JSObject::callObjVar(uintN i)
534 {
535     JSFunction *fun = getCallObjCalleeFunction();
536     JS_ASSERT(fun->nargs == fun->script()->bindings.countArgs());
537     JS_ASSERT(i < fun->script()->bindings.countVars());
538     return getSlotRef(JSObject::CALL_RESERVED_SLOTS + fun->nargs + i);
539 }
540
541 inline const js::Value &
542 JSObject::getDateUTCTime() const
543 {
544     JS_ASSERT(isDate());
545     return getSlot(JSSLOT_DATE_UTC_TIME);
546 }
547
548 inline void 
549 JSObject::setDateUTCTime(const js::Value &time)
550 {
551     JS_ASSERT(isDate());
552     setSlot(JSSLOT_DATE_UTC_TIME, time);
553 }
554
555 inline js::Value *
556 JSObject::getFlatClosureUpvars() const
557 {
558 #ifdef DEBUG
559     JSFunction *fun = getFunctionPrivate();
560     JS_ASSERT(fun->isFlatClosure());
561     JS_ASSERT(fun->script()->bindings.countUpvars() == fun->script()->upvars()->length);
562 #endif
563     return (js::Value *) getSlot(JSSLOT_FLAT_CLOSURE_UPVARS).toPrivate();
564 }
565
566 inline js::Value
567 JSObject::getFlatClosureUpvar(uint32 i) const
568 {
569     JS_ASSERT(i < getFunctionPrivate()->script()->bindings.countUpvars());
570     return getFlatClosureUpvars()[i];
571 }
572
573 inline js::Value &
574 JSObject::getFlatClosureUpvar(uint32 i)
575 {
576     JS_ASSERT(i < getFunctionPrivate()->script()->bindings.countUpvars());
577     return getFlatClosureUpvars()[i];
578 }
579
580 inline void
581 JSObject::setFlatClosureUpvars(js::Value *upvars)
582 {
583     JS_ASSERT(isFunction());
584     JS_ASSERT(FUN_FLAT_CLOSURE(getFunctionPrivate()));
585     getSlotRef(JSSLOT_FLAT_CLOSURE_UPVARS).setPrivate(upvars);
586 }
587
588 inline bool
589 JSObject::hasMethodObj(const JSObject& obj) const
590 {
591     return JSSLOT_FUN_METHOD_OBJ < numSlots() &&
592            getSlot(JSSLOT_FUN_METHOD_OBJ).isObject() &&
593            &getSlot(JSSLOT_FUN_METHOD_OBJ).toObject() == &obj;
594 }
595
596 inline void
597 JSObject::setMethodObj(JSObject& obj)
598 {
599     getSlotRef(JSSLOT_FUN_METHOD_OBJ).setObject(obj);
600 }
601
602 inline js::NativeIterator *
603 JSObject::getNativeIterator() const
604 {
605     return (js::NativeIterator *) getPrivate();
606 }
607
608 inline void
609 JSObject::setNativeIterator(js::NativeIterator *ni)
610 {
611     setPrivate(ni);
612 }
613
614 inline JSLinearString *
615 JSObject::getNamePrefix() const
616 {
617     JS_ASSERT(isNamespace() || isQName());
618     const js::Value &v = getSlot(JSSLOT_NAME_PREFIX);
619     return !v.isUndefined() ? v.toString()->assertIsLinear() : NULL;
620 }
621
622 inline jsval
623 JSObject::getNamePrefixVal() const
624 {
625     JS_ASSERT(isNamespace() || isQName());
626     return js::Jsvalify(getSlot(JSSLOT_NAME_PREFIX));
627 }
628
629 inline void
630 JSObject::setNamePrefix(JSLinearString *prefix)
631 {
632     JS_ASSERT(isNamespace() || isQName());
633     setSlot(JSSLOT_NAME_PREFIX, prefix ? js::StringValue(prefix) : js::UndefinedValue());
634 }
635
636 inline void
637 JSObject::clearNamePrefix()
638 {
639     JS_ASSERT(isNamespace() || isQName());
640     setSlot(JSSLOT_NAME_PREFIX, js::UndefinedValue());
641 }
642
643 inline JSLinearString *
644 JSObject::getNameURI() const
645 {
646     JS_ASSERT(isNamespace() || isQName());
647     const js::Value &v = getSlot(JSSLOT_NAME_URI);
648     return !v.isUndefined() ? v.toString()->assertIsLinear() : NULL;
649 }
650
651 inline jsval
652 JSObject::getNameURIVal() const
653 {
654     JS_ASSERT(isNamespace() || isQName());
655     return js::Jsvalify(getSlot(JSSLOT_NAME_URI));
656 }
657
658 inline void
659 JSObject::setNameURI(JSLinearString *uri)
660 {
661     JS_ASSERT(isNamespace() || isQName());
662     setSlot(JSSLOT_NAME_URI, uri ? js::StringValue(uri) : js::UndefinedValue());
663 }
664
665 inline jsval
666 JSObject::getNamespaceDeclared() const
667 {
668     JS_ASSERT(isNamespace());
669     return js::Jsvalify(getSlot(JSSLOT_NAMESPACE_DECLARED));
670 }
671
672 inline void
673 JSObject::setNamespaceDeclared(jsval decl)
674 {
675     JS_ASSERT(isNamespace());
676     setSlot(JSSLOT_NAMESPACE_DECLARED, js::Valueify(decl));
677 }
678
679 inline JSLinearString *
680 JSObject::getQNameLocalName() const
681 {
682     JS_ASSERT(isQName());
683     const js::Value &v = getSlot(JSSLOT_QNAME_LOCAL_NAME);
684     return !v.isUndefined() ? v.toString()->assertIsLinear() : NULL;
685 }
686
687 inline jsval
688 JSObject::getQNameLocalNameVal() const
689 {
690     JS_ASSERT(isQName());
691     return js::Jsvalify(getSlot(JSSLOT_QNAME_LOCAL_NAME));
692 }
693
694 inline void
695 JSObject::setQNameLocalName(JSLinearString *name)
696 {
697     JS_ASSERT(isQName());
698     setSlot(JSSLOT_QNAME_LOCAL_NAME, name ? js::StringValue(name) : js::UndefinedValue());
699 }
700
701 inline JSObject *
702 JSObject::getWithThis() const
703 {
704     return &getSlot(JSSLOT_WITH_THIS).toObject();
705 }
706
707 inline void
708 JSObject::setWithThis(JSObject *thisp)
709 {
710     getSlotRef(JSSLOT_WITH_THIS).setObject(*thisp);
711 }
712
713 inline void
714 JSObject::init(JSContext *cx, js::Class *aclasp, JSObject *proto, JSObject *parent,
715                void *priv, bool useHoles)
716 {
717     clasp = aclasp;
718     flags = 0;
719
720 #ifdef DEBUG
721     /*
722      * NB: objShape must not be set here; rather, the caller must call setMap
723      * or setSharedNonNativeMap after calling init. To defend this requirement
724      * we set map to null in DEBUG builds, and set objShape to a value we then
725      * assert obj->shape() never returns.
726      */
727     map = NULL;
728     objShape = JSObjectMap::INVALID_SHAPE;
729 #endif
730
731     setProto(proto);
732     setParent(parent);
733
734     privateData = priv;
735     slots = fixedSlots();
736
737     /*
738      * Fill the fixed slots with undefined or array holes.  This object must
739      * already have its capacity filled in, as by js_NewGCObject.
740      */
741     JS_ASSERT(capacity == numFixedSlots());
742     ClearValueRange(slots, capacity, useHoles);
743
744     emptyShapes = NULL;
745 }
746
747 inline void
748 JSObject::finish(JSContext *cx)
749 {
750 #ifdef DEBUG
751     if (isNative())
752         JS_LOCK_RUNTIME_VOID(cx->runtime, cx->runtime->liveObjectProps -= propertyCount());
753 #endif
754     if (hasSlotsArray())
755         freeSlotsArray(cx);
756     if (emptyShapes)
757         cx->free(emptyShapes);
758 }
759
760 inline bool
761 JSObject::initSharingEmptyShape(JSContext *cx,
762                                 js::Class *aclasp,
763                                 JSObject *proto,
764                                 JSObject *parent,
765                                 void *privateValue,
766                                 /* js::gc::FinalizeKind */ unsigned kind)
767 {
768     init(cx, aclasp, proto, parent, privateValue, false);
769
770     JS_ASSERT(!isDenseArray());
771
772     js::EmptyShape *empty = proto->getEmptyShape(cx, aclasp, kind);
773     if (!empty)
774         return false;
775
776     setMap(empty);
777     return true;
778 }
779
780 inline void
781 JSObject::freeSlotsArray(JSContext *cx)
782 {
783     JS_ASSERT(hasSlotsArray());
784     cx->free(slots);
785 }
786
787 inline void
788 JSObject::revertToFixedSlots(JSContext *cx)
789 {
790     JS_ASSERT(hasSlotsArray());
791     size_t fixed = numFixedSlots();
792     JS_ASSERT(capacity >= fixed);
793     memcpy(fixedSlots(), slots, fixed * sizeof(js::Value));
794     freeSlotsArray(cx);
795     slots = fixedSlots();
796     capacity = fixed;
797 }
798
799 inline bool
800 JSObject::hasProperty(JSContext *cx, jsid id, bool *foundp, uintN flags)
801 {
802     JSObject *pobj;
803     JSProperty *prop;
804     JSAutoResolveFlags rf(cx, flags);
805     if (!lookupProperty(cx, id, &pobj, &prop))
806         return false;
807     *foundp = !!prop;
808     return true;
809 }
810
811 inline bool
812 JSObject::isCallable()
813 {
814     return isFunction() || getClass()->call;
815 }
816
817 static inline bool
818 js_IsCallable(const js::Value &v)
819 {
820     return v.isObject() && v.toObject().isCallable();
821 }
822
823 namespace js {
824
825 class AutoPropDescArrayRooter : private AutoGCRooter
826 {
827   public:
828     AutoPropDescArrayRooter(JSContext *cx)
829       : AutoGCRooter(cx, DESCRIPTORS), descriptors(cx)
830     { }
831
832     PropDesc *append() {
833         if (!descriptors.append(PropDesc()))
834             return NULL;
835         return &descriptors.back();
836     }
837
838     PropDesc& operator[](size_t i) {
839         JS_ASSERT(i < descriptors.length());
840         return descriptors[i];
841     }
842
843     friend void AutoGCRooter::trace(JSTracer *trc);
844
845   private:
846     PropDescArray descriptors;
847 };
848
849 class AutoPropertyDescriptorRooter : private AutoGCRooter, public PropertyDescriptor
850 {
851   public:
852     AutoPropertyDescriptorRooter(JSContext *cx) : AutoGCRooter(cx, DESCRIPTOR) {
853         obj = NULL;
854         attrs = 0;
855         getter = (PropertyOp) NULL;
856         setter = (StrictPropertyOp) NULL;
857         value.setUndefined();
858     }
859
860     AutoPropertyDescriptorRooter(JSContext *cx, PropertyDescriptor *desc)
861       : AutoGCRooter(cx, DESCRIPTOR)
862     {
863         obj = desc->obj;
864         attrs = desc->attrs;
865         getter = desc->getter;
866         setter = desc->setter;
867         value = desc->value;
868     }
869
870     friend void AutoGCRooter::trace(JSTracer *trc);
871 };
872
873 static inline bool
874 InitScopeForObject(JSContext* cx, JSObject* obj, js::Class *clasp, JSObject* proto,
875                    gc::FinalizeKind kind)
876 {
877     JS_ASSERT(clasp->isNative());
878     JS_ASSERT(proto == obj->getProto());
879
880     /* Share proto's emptyShape only if obj is similar to proto. */
881     js::EmptyShape *empty = NULL;
882
883     if (proto) {
884         if (proto->canProvideEmptyShape(clasp)) {
885             empty = proto->getEmptyShape(cx, clasp, kind);
886             if (!empty)
887                 goto bad;
888         }
889     }
890
891     if (!empty) {
892         empty = js::EmptyShape::create(cx, clasp);
893         if (!empty)
894             goto bad;
895         uint32 freeslot = JSSLOT_FREE(clasp);
896         if (freeslot > obj->numSlots() && !obj->allocSlots(cx, freeslot))
897             goto bad;
898     }
899
900     obj->setMap(empty);
901     return true;
902
903   bad:
904     /* The GC nulls map initially. It should still be null on error. */
905     JS_ASSERT(!obj->map);
906     return false;
907 }
908
909 /*
910  * Helper optimized for creating a native instance of the given class (not the
911  * class's prototype object). Use this in preference to NewObject, but use
912  * NewBuiltinClassInstance if you need the default class prototype as proto,
913  * and its parent global as parent.
914  */
915 static inline JSObject *
916 NewNativeClassInstance(JSContext *cx, Class *clasp, JSObject *proto,
917                        JSObject *parent, gc::FinalizeKind kind)
918 {
919     JS_ASSERT(proto);
920     JS_ASSERT(parent);
921
922     /*
923      * Allocate an object from the GC heap and initialize all its fields before
924      * doing any operation that can potentially trigger GC.
925      */
926     JSObject* obj = js_NewGCObject(cx, kind);
927
928     if (obj) {
929         /*
930          * Default parent to the parent of the prototype, which was set from
931          * the parent of the prototype's constructor.
932          */
933         bool useHoles = (clasp == &js_ArrayClass);
934         obj->init(cx, clasp, proto, parent, NULL, useHoles);
935
936         JS_ASSERT(proto->canProvideEmptyShape(clasp));
937         js::EmptyShape *empty = proto->getEmptyShape(cx, clasp, kind);
938
939         if (empty)
940             obj->setMap(empty);
941         else
942             obj = NULL;
943     }
944
945     return obj;
946 }
947
948 static inline JSObject *
949 NewNativeClassInstance(JSContext *cx, Class *clasp, JSObject *proto, JSObject *parent)
950 {
951     gc::FinalizeKind kind = gc::GetGCObjectKind(JSCLASS_RESERVED_SLOTS(clasp));
952     return NewNativeClassInstance(cx, clasp, proto, parent, kind);
953 }
954
955 bool
956 FindClassPrototype(JSContext *cx, JSObject *scope, JSProtoKey protoKey, JSObject **protop,
957                    Class *clasp);
958
959 /*
960  * Helper used to create Boolean, Date, RegExp, etc. instances of built-in
961  * classes with class prototypes of the same Class. See, e.g., jsdate.cpp,
962  * jsregexp.cpp, and js_PrimitiveToObject in jsobj.cpp. Use this to get the
963  * right default proto and parent for clasp in cx.
964  */
965 static inline JSObject *
966 NewBuiltinClassInstance(JSContext *cx, Class *clasp, gc::FinalizeKind kind)
967 {
968     VOUCH_DOES_NOT_REQUIRE_STACK();
969
970     JSProtoKey protoKey = JSCLASS_CACHED_PROTO_KEY(clasp);
971     JS_ASSERT(protoKey != JSProto_Null);
972
973     /* NB: inline-expanded and specialized version of js_GetClassPrototype. */
974     JSObject *global;
975     if (!cx->hasfp()) {
976         global = cx->globalObject;
977         OBJ_TO_INNER_OBJECT(cx, global);
978         if (!global)
979             return NULL;
980     } else {
981         global = cx->fp()->scopeChain().getGlobal();
982     }
983     JS_ASSERT(global->isGlobal());
984
985     const Value &v = global->getReservedSlot(JSProto_LIMIT + protoKey);
986     JSObject *proto;
987     if (v.isObject()) {
988         proto = &v.toObject();
989         JS_ASSERT(proto->getParent() == global);
990     } else {
991         if (!FindClassPrototype(cx, global, protoKey, &proto, clasp))
992             return NULL;
993     }
994
995     return NewNativeClassInstance(cx, clasp, proto, global, kind);
996 }
997
998 static inline JSObject *
999 NewBuiltinClassInstance(JSContext *cx, Class *clasp)
1000 {
1001     gc::FinalizeKind kind = gc::GetGCObjectKind(JSCLASS_RESERVED_SLOTS(clasp));
1002     return NewBuiltinClassInstance(cx, clasp, kind);
1003 }
1004
1005 static inline JSProtoKey
1006 GetClassProtoKey(js::Class *clasp)
1007 {
1008     JSProtoKey key = JSCLASS_CACHED_PROTO_KEY(clasp);
1009     if (key != JSProto_Null)
1010         return key;
1011     if (clasp->flags & JSCLASS_IS_ANONYMOUS)
1012         return JSProto_Object;
1013     return JSProto_Null;
1014 }
1015
1016 namespace WithProto {
1017     enum e {
1018         Class = 0,
1019         Given = 1
1020     };
1021 }
1022
1023 /*
1024  * Create an instance of any class, native or not, JSFunction-sized or not.
1025  *
1026  * If withProto is 'Class':
1027  *    If proto is null:
1028  *      for a built-in class:
1029  *        use the memoized original value of the class constructor .prototype
1030  *        property object
1031  *      else if available
1032  *        the current value of .prototype
1033  *      else
1034  *        Object.prototype.
1035  *
1036  *    If parent is null, default it to proto->getParent() if proto is non
1037  *    null, else to null.
1038  *
1039  * If withProto is 'Given':
1040  *    We allocate an object with exactly the given proto.  A null parent
1041  *    defaults to proto->getParent() if proto is non-null (else to null).
1042  *
1043  * If isFunction is true, return a JSFunction-sized object. If isFunction is
1044  * false, return a normal object.
1045  *
1046  * Note that as a template, there will be lots of instantiations, which means
1047  * the internals will be specialized based on the template parameters.
1048  */
1049 static JS_ALWAYS_INLINE bool
1050 FindProto(JSContext *cx, js::Class *clasp, JSObject *parent, JSObject ** proto)
1051 {
1052     JSProtoKey protoKey = GetClassProtoKey(clasp);
1053     if (!js_GetClassPrototype(cx, parent, protoKey, proto, clasp))
1054         return false;
1055     if (!(*proto) && !js_GetClassPrototype(cx, parent, JSProto_Object, proto))
1056         return false;
1057
1058     return true;
1059 }
1060
1061 namespace detail
1062 {
1063 template <bool withProto, bool isFunction>
1064 static JS_ALWAYS_INLINE JSObject *
1065 NewObject(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent,
1066           gc::FinalizeKind kind)
1067 {
1068     /* Bootstrap the ur-object, and make it the default prototype object. */
1069     if (withProto == WithProto::Class && !proto) {
1070         if (!FindProto(cx, clasp, parent, &proto))
1071           return NULL;
1072     }
1073
1074     /*
1075      * Allocate an object from the GC heap and initialize all its fields before
1076      * doing any operation that can potentially trigger GC. Functions have a
1077      * larger non-standard allocation size.
1078      *
1079      * The should be specialized by the template.
1080      */
1081     JSObject* obj = isFunction ? js_NewGCFunction(cx) : js_NewGCObject(cx, kind);
1082     if (!obj)
1083         goto out;
1084
1085     /* This needs to match up with the size of JSFunction::data_padding. */
1086     JS_ASSERT_IF(isFunction, kind == gc::FINALIZE_OBJECT2);
1087
1088     /*
1089      * Default parent to the parent of the prototype, which was set from
1090      * the parent of the prototype's constructor.
1091      */
1092     obj->init(cx, clasp, proto,
1093               (!parent && proto) ? proto->getParent() : parent,
1094               NULL, clasp == &js_ArrayClass);
1095
1096     if (clasp->isNative()) {
1097         if (!InitScopeForObject(cx, obj, clasp, proto, kind)) {
1098             obj = NULL;
1099             goto out;
1100         }
1101     } else {
1102         obj->setSharedNonNativeMap();
1103     }
1104
1105 out:
1106     Probes::createObject(cx, obj);
1107     return obj;
1108 }
1109 } /* namespace detail */
1110
1111 static JS_ALWAYS_INLINE JSObject *
1112 NewFunction(JSContext *cx, JSObject *parent)
1113 {
1114     return detail::NewObject<WithProto::Class, true>(cx, &js_FunctionClass, NULL, parent,
1115                                                      gc::FINALIZE_OBJECT2);
1116 }
1117
1118 template <WithProto::e withProto>
1119 static JS_ALWAYS_INLINE JSObject *
1120 NewNonFunction(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent,
1121                gc::FinalizeKind kind)
1122 {
1123     return detail::NewObject<withProto, false>(cx, clasp, proto, parent, kind);
1124 }
1125
1126 template <WithProto::e withProto>
1127 static JS_ALWAYS_INLINE JSObject *
1128 NewNonFunction(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent)
1129 {
1130     gc::FinalizeKind kind = gc::GetGCObjectKind(JSCLASS_RESERVED_SLOTS(clasp));
1131     return detail::NewObject<withProto, false>(cx, clasp, proto, parent, kind);
1132 }
1133
1134 template <WithProto::e withProto>
1135 static JS_ALWAYS_INLINE JSObject *
1136 NewObject(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent,
1137           gc::FinalizeKind kind)
1138 {
1139     if (clasp == &js_FunctionClass)
1140         return detail::NewObject<withProto, true>(cx, clasp, proto, parent, kind);
1141     return detail::NewObject<withProto, false>(cx, clasp, proto, parent, kind);
1142 }
1143
1144 template <WithProto::e withProto>
1145 static JS_ALWAYS_INLINE JSObject *
1146 NewObject(JSContext *cx, js::Class *clasp, JSObject *proto, JSObject *parent)
1147 {
1148     gc::FinalizeKind kind = gc::GetGCObjectKind(JSCLASS_RESERVED_SLOTS(clasp));
1149     return NewObject<withProto>(cx, clasp, proto, parent, kind);
1150 }
1151
1152 /*
1153  * As for gc::GetGCObjectKind, where numSlots is a guess at the final size of
1154  * the object, zero if the final size is unknown.
1155  */
1156 static inline gc::FinalizeKind
1157 GuessObjectGCKind(size_t numSlots, bool isArray)
1158 {
1159     if (numSlots)
1160         return gc::GetGCObjectKind(numSlots);
1161     return isArray ? gc::FINALIZE_OBJECT8 : gc::FINALIZE_OBJECT4;
1162 }
1163
1164 /*
1165  * Get the GC kind to use for scripted 'new' on the given class.
1166  * FIXME bug 547327: estimate the size from the allocation site.
1167  */
1168 static inline gc::FinalizeKind
1169 NewObjectGCKind(JSContext *cx, js::Class *clasp)
1170 {
1171     if (clasp == &js_ArrayClass || clasp == &js_SlowArrayClass)
1172         return gc::FINALIZE_OBJECT8;
1173     if (clasp == &js_FunctionClass)
1174         return gc::FINALIZE_OBJECT2;
1175     return gc::FINALIZE_OBJECT4;
1176 }
1177
1178 /* Make an object with pregenerated shape from a NEWOBJECT bytecode. */
1179 static inline JSObject *
1180 CopyInitializerObject(JSContext *cx, JSObject *baseobj)
1181 {
1182     JS_ASSERT(baseobj->getClass() == &js_ObjectClass);
1183     JS_ASSERT(!baseobj->inDictionaryMode());
1184
1185     gc::FinalizeKind kind = gc::FinalizeKind(baseobj->finalizeKind());
1186     JSObject *obj = NewBuiltinClassInstance(cx, &js_ObjectClass, kind);
1187
1188     if (!obj || !obj->ensureSlots(cx, baseobj->numSlots()))
1189         return NULL;
1190
1191     obj->flags = baseobj->flags;
1192     obj->lastProp = baseobj->lastProp;
1193     obj->objShape = baseobj->objShape;
1194
1195     return obj;
1196 }
1197
1198 /*
1199  * When we have an object of a builtin class, we don't quite know what its
1200  * valueOf/toString methods are, since these methods may have been overwritten
1201  * or shadowed. However, we can still do better than js_TryMethod by
1202  * hard-coding the necessary properties for us to find the native we expect.
1203  *
1204  * TODO: a per-thread shape-based cache would be faster and simpler.
1205  */
1206 static JS_ALWAYS_INLINE bool
1207 ClassMethodIsNative(JSContext *cx, JSObject *obj, Class *clasp, jsid methodid,
1208                     Native native)
1209 {
1210     JS_ASSERT(obj->getClass() == clasp);
1211
1212     if (HasNativeMethod(obj, methodid, native))
1213         return true;
1214
1215     JSObject *pobj = obj->getProto();
1216     return pobj && pobj->getClass() == clasp &&
1217            HasNativeMethod(pobj, methodid, native);
1218 }
1219
1220 } /* namespace js */
1221
1222 #endif /* jsobjinlines_h___ */