1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
3
* ***** BEGIN LICENSE BLOCK *****
4
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
6
* The contents of this file are subject to the Mozilla Public License Version
7
* 1.1 (the "License"); you may not use this file except in compliance with
8
* the License. You may obtain a copy of the License at
9
* http://www.mozilla.org/MPL/
11
* Software distributed under the License is distributed on an "AS IS" basis,
12
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13
* for the specific language governing rights and limitations under the
16
* The Original Code is Mozilla Communicator client code, released
19
* The Initial Developer of the Original Code is
20
* Netscape Communications Corporation.
21
* Portions created by the Initial Developer are Copyright (C) 1998
22
* the Initial Developer. All Rights Reserved.
26
* Alternatively, the contents of this file may be used under the terms of
27
* either of the GNU General Public License Version 2 or later (the "GPL"),
28
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29
* in which case the provisions of the GPL or the LGPL are applicable instead
30
* of those above. If you wish to allow use of your version of this file only
31
* under the terms of either the GPL or the LGPL, and not to allow others to
32
* use your version of this file under the terms of the MPL, indicate your
33
* decision by deleting the provisions above and replace them with the notice
34
* and other provisions required by the GPL or the LGPL. If you do not delete
35
* the provisions above, a recipient may use your version of this file under
36
* the terms of any one of the MPL, the GPL or the LGPL.
38
* ***** END LICENSE BLOCK ***** */
43
* JS public API typedefs.
50
/* Scalar typedefs. */
51
typedef uint16 jschar;
53
typedef uint32 jsuint;
54
typedef float64 jsdouble;
57
typedef int32 jsrefcount; /* PRInt32 if JS_THREADSAFE, see jslock.h */
60
* Run-time version enumeration. See jsconfig.h for compile-time counterparts
61
* to these values that may be selected by the JS_VERSION macro, and tested by
64
typedef enum JSVersion {
70
JSVERSION_ECMA_3 = 148,
74
JSVERSION_DEFAULT = 0,
75
JSVERSION_UNKNOWN = -1
78
#define JSVERSION_IS_ECMA(version) \
79
((version) == JSVERSION_DEFAULT || (version) >= JSVERSION_1_3)
81
/* Result of typeof operator enumeration. */
83
JSTYPE_VOID, /* undefined */
84
JSTYPE_OBJECT, /* object */
85
JSTYPE_FUNCTION, /* function */
86
JSTYPE_STRING, /* string */
87
JSTYPE_NUMBER, /* number */
88
JSTYPE_BOOLEAN, /* boolean */
89
JSTYPE_NULL, /* null */
90
JSTYPE_XML, /* xml object */
94
/* Dense index into cached prototypes and class atoms for standard objects. */
95
typedef enum JSProtoKey {
96
#define JS_PROTO(name,code,init) JSProto_##name = code,
97
#include "jsproto.tbl"
102
/* JSObjectOps.checkAccess mode enumeration. */
103
typedef enum JSAccessMode {
104
JSACC_PROTO = 0, /* XXXbe redundant w.r.t. id */
105
JSACC_PARENT = 1, /* XXXbe redundant w.r.t. id */
106
JSACC_IMPORT = 2, /* import foo.bar */
107
JSACC_WATCH = 3, /* a watchpoint on object foo for id 'bar' */
108
JSACC_READ = 4, /* a "get" of foo.bar */
109
JSACC_WRITE = 8, /* a "set" of foo.bar = baz */
113
#define JSACC_TYPEMASK (JSACC_WRITE - 1)
116
* This enum type is used to control the behavior of a JSObject property
117
* iterator function that has type JSNewEnumerate.
119
typedef enum JSIterateOp {
120
JSENUMERATE_INIT, /* Create new iterator state */
121
JSENUMERATE_NEXT, /* Iterate once */
122
JSENUMERATE_DESTROY /* Destroy iterator state */
125
/* Struct typedefs. */
126
typedef struct JSClass JSClass;
127
typedef struct JSExtendedClass JSExtendedClass;
128
typedef struct JSConstDoubleSpec JSConstDoubleSpec;
129
typedef struct JSContext JSContext;
130
typedef struct JSErrorReport JSErrorReport;
131
typedef struct JSFunction JSFunction;
132
typedef struct JSFunctionSpec JSFunctionSpec;
133
typedef struct JSIdArray JSIdArray;
134
typedef struct JSProperty JSProperty;
135
typedef struct JSPropertySpec JSPropertySpec;
136
typedef struct JSObject JSObject;
137
typedef struct JSObjectMap JSObjectMap;
138
typedef struct JSObjectOps JSObjectOps;
139
typedef struct JSXMLObjectOps JSXMLObjectOps;
140
typedef struct JSRuntime JSRuntime;
141
typedef struct JSRuntime JSTaskState; /* XXX deprecated name */
142
typedef struct JSScript JSScript;
143
typedef struct JSStackFrame JSStackFrame;
144
typedef struct JSString JSString;
145
typedef struct JSXDRState JSXDRState;
146
typedef struct JSExceptionState JSExceptionState;
147
typedef struct JSLocaleCallbacks JSLocaleCallbacks;
149
/* JSClass (and JSObjectOps where appropriate) function pointer typedefs. */
152
* Add, delete, get or set a property named by id in obj. Note the jsval id
153
* type -- id may be a string (Unicode property identifier) or an int (element
154
* index). The *vp out parameter, on success, is the new property value after
155
* an add, get, or set. After a successful delete, *vp is JSVAL_FALSE iff
156
* obj[id] can't be deleted (because it's permanent).
159
(* JS_DLL_CALLBACK JSPropertyOp)(JSContext *cx, JSObject *obj, jsval id,
163
* This function type is used for callbacks that enumerate the properties of
164
* a JSObject. The behavior depends on the value of enum_op:
167
* A new, opaque iterator state should be allocated and stored in *statep.
168
* (You can use PRIVATE_TO_JSVAL() to tag the pointer to be stored).
170
* The number of properties that will be enumerated should be returned as
171
* an integer jsval in *idp, if idp is non-null, and provided the number of
172
* enumerable properties is known. If idp is non-null and the number of
173
* enumerable properties can't be computed in advance, *idp should be set
177
* A previously allocated opaque iterator state is passed in via statep.
178
* Return the next jsid in the iteration using *idp. The opaque iterator
179
* state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
180
* if there are no properties left to enumerate.
182
* JSENUMERATE_DESTROY
183
* Destroy the opaque iterator state previously allocated in *statep by a
184
* call to this function when enum_op was JSENUMERATE_INIT.
186
* The return value is used to indicate success, with a value of JS_FALSE
187
* indicating failure.
190
(* JS_DLL_CALLBACK JSNewEnumerateOp)(JSContext *cx, JSObject *obj,
192
jsval *statep, jsid *idp);
195
* The old-style JSClass.enumerate op should define all lazy properties not
196
* yet reflected in obj.
199
(* JS_DLL_CALLBACK JSEnumerateOp)(JSContext *cx, JSObject *obj);
202
* Resolve a lazy property named by id in obj by defining it directly in obj.
203
* Lazy properties are those reflected from some peer native property space
204
* (e.g., the DOM attributes for a given node reflected as obj) on demand.
206
* JS looks for a property in an object, and if not found, tries to resolve
207
* the given id. If resolve succeeds, the engine looks again in case resolve
208
* defined obj[id]. If no such property exists directly in obj, the process
209
* is repeated with obj's prototype, etc.
211
* NB: JSNewResolveOp provides a cheaper way to resolve lazy properties.
214
(* JS_DLL_CALLBACK JSResolveOp)(JSContext *cx, JSObject *obj, jsval id);
217
* Like JSResolveOp, but flags provide contextual information as follows:
219
* JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
220
* JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
221
* JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
222
* JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
223
* JSRESOLVE_CLASSNAME class name used when constructing
225
* The *objp out parameter, on success, should be null to indicate that id
226
* was not resolved; and non-null, referring to obj or one of its prototypes,
227
* if id was resolved.
229
* This hook instead of JSResolveOp is called via the JSClass.resolve member
230
* if JSCLASS_NEW_RESOLVE is set in JSClass.flags.
232
* Setting JSCLASS_NEW_RESOLVE and JSCLASS_NEW_RESOLVE_GETS_START further
233
* extends this hook by passing in the starting object on the prototype chain
234
* via *objp. Thus a resolve hook implementation may define the property id
235
* being resolved in the object in which the id was first sought, rather than
236
* in a prototype object whose class led to the resolve hook being called.
238
* When using JSCLASS_NEW_RESOLVE_GETS_START, the resolve hook must therefore
239
* null *objp to signify "not resolved". With only JSCLASS_NEW_RESOLVE and no
240
* JSCLASS_NEW_RESOLVE_GETS_START, the hook can assume *objp is null on entry.
241
* This is not good practice, but enough existing hook implementations count
242
* on it that we can't break compatibility by passing the starting object in
243
* *objp without a new JSClass flag.
246
(* JS_DLL_CALLBACK JSNewResolveOp)(JSContext *cx, JSObject *obj, jsval id,
247
uintN flags, JSObject **objp);
250
* Convert obj to the given type, returning true with the resulting value in
251
* *vp on success, and returning false on error or exception.
254
(* JS_DLL_CALLBACK JSConvertOp)(JSContext *cx, JSObject *obj, JSType type,
258
* Finalize obj, which the garbage collector has determined to be unreachable
259
* from other live objects or from GC roots. Obviously, finalizers must never
260
* store a reference to obj.
263
(* JS_DLL_CALLBACK JSFinalizeOp)(JSContext *cx, JSObject *obj);
266
* Used by JS_AddExternalStringFinalizer and JS_RemoveExternalStringFinalizer
267
* to extend and reduce the set of string types finalized by the GC.
270
(* JS_DLL_CALLBACK JSStringFinalizeOp)(JSContext *cx, JSString *str);
273
* The signature for JSClass.getObjectOps, used by JS_NewObject's internals
274
* to discover the set of high-level object operations to use for new objects
275
* of the given class. All native objects have a JSClass, which is stored as
276
* a private (int-tagged) pointer in obj->slots[JSSLOT_CLASS]. In contrast,
277
* all native and host objects have a JSObjectMap at obj->map, which may be
278
* shared among a number of objects, and which contains the JSObjectOps *ops
279
* pointer used to dispatch object operations from API calls.
281
* Thus JSClass (which pre-dates JSObjectOps in the API) provides a low-level
282
* interface to class-specific code and data, while JSObjectOps allows for a
283
* higher level of operation, which does not use the object's class except to
284
* find the class's JSObjectOps struct, by calling clasp->getObjectOps, and to
285
* finalize the object.
287
* If this seems backwards, that's because it is! API compatibility requires
288
* a JSClass *clasp parameter to JS_NewObject, etc. Most host objects do not
289
* need to implement the larger JSObjectOps, and can share the common JSScope
290
* code and data used by the native (js_ObjectOps, see jsobj.c) ops.
292
* Further extension to preserve API compatibility: if this function returns
293
* a pointer to JSXMLObjectOps.base, not to JSObjectOps, then the engine calls
294
* extended hooks needed for E4X.
296
typedef JSObjectOps *
297
(* JS_DLL_CALLBACK JSGetObjectOps)(JSContext *cx, JSClass *clasp);
300
* JSClass.checkAccess type: check whether obj[id] may be accessed per mode,
301
* returning false on error/exception, true on success with obj[id]'s last-got
302
* value in *vp, and its attributes in *attrsp. As for JSPropertyOp above, id
303
* is either a string or an int jsval.
305
* See JSCheckAccessIdOp, below, for the JSObjectOps counterpart, which takes
306
* a jsid (a tagged int or aligned, unique identifier pointer) rather than a
307
* jsval. The native js_ObjectOps.checkAccess simply forwards to the object's
308
* clasp->checkAccess, so that both JSClass and JSObjectOps implementors may
309
* specialize access checks.
312
(* JS_DLL_CALLBACK JSCheckAccessOp)(JSContext *cx, JSObject *obj, jsval id,
313
JSAccessMode mode, jsval *vp);
316
* Encode or decode an object, given an XDR state record representing external
317
* data. See jsxdrapi.h.
320
(* JS_DLL_CALLBACK JSXDRObjectOp)(JSXDRState *xdr, JSObject **objp);
323
* Check whether v is an instance of obj. Return false on error or exception,
324
* true on success with JS_TRUE in *bp if v is an instance of obj, JS_FALSE in
328
(* JS_DLL_CALLBACK JSHasInstanceOp)(JSContext *cx, JSObject *obj, jsval v,
332
* Function type for JSClass.mark and JSObjectOps.mark, called from the GC to
333
* scan live GC-things reachable from obj's private data structure. For each
334
* such thing, a mark implementation must call
336
* JS_MarkGCThing(cx, thing, name, arg);
338
* The trailing name and arg parameters are used for GC_MARK_DEBUG-mode heap
339
* dumping and ref-path tracing. The mark function should pass a (typically
340
* literal) string naming the private data member for name, and it must pass
341
* the opaque arg parameter through from its caller.
343
* For the JSObjectOps.mark hook, the return value is the number of slots at
344
* obj->slots to scan. For JSClass.mark, the return value is ignored.
346
* NB: JSMarkOp implementations cannot allocate new GC-things (JS_NewObject
347
* called from a mark function will fail silently, e.g.).
350
(* JS_DLL_CALLBACK JSMarkOp)(JSContext *cx, JSObject *obj, void *arg);
353
* The optional JSClass.reserveSlots hook allows a class to make computed
354
* per-instance object slots reservations, in addition to or instead of using
355
* JSCLASS_HAS_RESERVED_SLOTS(n) in the JSClass.flags initializer to reserve
356
* a constant-per-class number of slots. Implementations of this hook should
357
* return the number of slots to reserve, not including any reserved by using
358
* JSCLASS_HAS_RESERVED_SLOTS(n) in JSClass.flags.
360
* NB: called with obj locked by the JSObjectOps-specific mutual exclusion
361
* mechanism appropriate for obj, so don't nest other operations that might
365
(* JS_DLL_CALLBACK JSReserveSlotsOp)(JSContext *cx, JSObject *obj);
367
/* JSObjectOps function pointer typedefs. */
370
* Create a new subclass of JSObjectMap (see jsobj.h), with the nrefs and ops
371
* members initialized from the same-named parameters, and with the nslots and
372
* freeslot members initialized according to ops and clasp. Return null on
373
* error, non-null on success.
375
* JSObjectMaps are reference-counted by generic code in the engine. Usually,
376
* the nrefs parameter to JSObjectOps.newObjectMap will be 1, to count the ref
377
* returned to the caller on success. After a successful construction, some
378
* number of js_HoldObjectMap and js_DropObjectMap calls ensue. When nrefs
379
* reaches 0 due to a js_DropObjectMap call, JSObjectOps.destroyObjectMap will
380
* be called to dispose of the map.
382
typedef JSObjectMap *
383
(* JS_DLL_CALLBACK JSNewObjectMapOp)(JSContext *cx, jsrefcount nrefs,
384
JSObjectOps *ops, JSClass *clasp,
388
* Generic type for an infallible JSObjectMap operation, used currently by
389
* JSObjectOps.destroyObjectMap.
392
(* JS_DLL_CALLBACK JSObjectMapOp)(JSContext *cx, JSObjectMap *map);
395
* Look for id in obj and its prototype chain, returning false on error or
396
* exception, true on success. On success, return null in *propp if id was
397
* not found. If id was found, return the first object searching from obj
398
* along its prototype chain in which id names a direct property in *objp, and
399
* return a non-null, opaque property pointer in *propp.
401
* If JSLookupPropOp succeeds and returns with *propp non-null, that pointer
402
* may be passed as the prop parameter to a JSAttributesOp, as a short-cut
403
* that bypasses id re-lookup. In any case, a non-null *propp result after a
404
* successful lookup must be dropped via JSObjectOps.dropProperty.
406
* NB: successful return with non-null *propp means the implementation may
407
* have locked *objp and added a reference count associated with *propp, so
408
* callers should not risk deadlock by nesting or interleaving other lookups
409
* or any obj-bearing ops before dropping *propp.
412
(* JS_DLL_CALLBACK JSLookupPropOp)(JSContext *cx, JSObject *obj, jsid id,
413
JSObject **objp, JSProperty **propp);
416
* Define obj[id], a direct property of obj named id, having the given initial
417
* value, with the specified getter, setter, and attributes. If the propp out
418
* param is non-null, *propp on successful return contains an opaque property
419
* pointer usable as a speedup hint with JSAttributesOp. But note that propp
420
* may be null, indicating that the caller is not interested in recovering an
421
* opaque pointer to the newly-defined property.
423
* If propp is non-null and JSDefinePropOp succeeds, its caller must be sure
424
* to drop *propp using JSObjectOps.dropProperty in short order, just as with
428
(* JS_DLL_CALLBACK JSDefinePropOp)(JSContext *cx, JSObject *obj,
429
jsid id, jsval value,
430
JSPropertyOp getter, JSPropertyOp setter,
431
uintN attrs, JSProperty **propp);
434
* Get, set, or delete obj[id], returning false on error or exception, true
435
* on success. If getting or setting, the new value is returned in *vp on
436
* success. If deleting without error, *vp will be JSVAL_FALSE if obj[id] is
437
* permanent, and JSVAL_TRUE if id named a direct property of obj that was in
438
* fact deleted, or if id names no direct property of obj (id could name a
439
* prototype property, or no property in obj or its prototype chain).
442
(* JS_DLL_CALLBACK JSPropertyIdOp)(JSContext *cx, JSObject *obj, jsid id,
446
* Get or set attributes of the property obj[id]. Return false on error or
447
* exception, true with current attributes in *attrsp. If prop is non-null,
448
* it must come from the *propp out parameter of a prior JSDefinePropOp or
449
* JSLookupPropOp call.
452
(* JS_DLL_CALLBACK JSAttributesOp)(JSContext *cx, JSObject *obj, jsid id,
453
JSProperty *prop, uintN *attrsp);
456
* JSObjectOps.checkAccess type: check whether obj[id] may be accessed per
457
* mode, returning false on error/exception, true on success with obj[id]'s
458
* last-got value in *vp, and its attributes in *attrsp.
461
(* JS_DLL_CALLBACK JSCheckAccessIdOp)(JSContext *cx, JSObject *obj, jsid id,
462
JSAccessMode mode, jsval *vp,
466
* A generic type for functions mapping an object to another object, or null
467
* if an error or exception was thrown on cx. Used by JSObjectOps.thisObject
471
(* JS_DLL_CALLBACK JSObjectOp)(JSContext *cx, JSObject *obj);
474
* A generic type for functions taking a context, object, and property, with
475
* no return value. Used by JSObjectOps.dropProperty currently (see above,
476
* JSDefinePropOp and JSLookupPropOp, for the object-locking protocol in which
477
* dropProperty participates).
480
(* JS_DLL_CALLBACK JSPropertyRefOp)(JSContext *cx, JSObject *obj,
484
* Function type for JSObjectOps.setProto and JSObjectOps.setParent. These
485
* hooks must check for cycles without deadlocking, and otherwise take special
486
* steps. See jsobj.c, js_SetProtoOrParent, for an example.
489
(* JS_DLL_CALLBACK JSSetObjectSlotOp)(JSContext *cx, JSObject *obj,
490
uint32 slot, JSObject *pobj);
493
* Get and set a required slot, one that should already have been allocated.
494
* These operations are infallible, so required slots must be pre-allocated,
495
* or implementations must suppress out-of-memory errors. The native ops
496
* (js_ObjectOps, see jsobj.c) access slots reserved by including a call to
497
* the JSCLASS_HAS_RESERVED_SLOTS(n) macro in the JSClass.flags initializer.
499
* NB: the slot parameter is a zero-based index into obj->slots[], unlike the
500
* index parameter to the JS_GetReservedSlot and JS_SetReservedSlot API entry
501
* points, which is a zero-based index into the JSCLASS_RESERVED_SLOTS(clasp)
502
* reserved slots that come after the initial well-known slots: proto, parent,
503
* class, and optionally, the private data slot.
506
(* JS_DLL_CALLBACK JSGetRequiredSlotOp)(JSContext *cx, JSObject *obj,
510
(* JS_DLL_CALLBACK JSSetRequiredSlotOp)(JSContext *cx, JSObject *obj,
511
uint32 slot, jsval v);
514
(* JS_DLL_CALLBACK JSGetMethodOp)(JSContext *cx, JSObject *obj, jsid id,
518
(* JS_DLL_CALLBACK JSSetMethodOp)(JSContext *cx, JSObject *obj, jsid id,
522
(* JS_DLL_CALLBACK JSEnumerateValuesOp)(JSContext *cx, JSObject *obj,
524
jsval *statep, jsid *idp, jsval *vp);
527
(* JS_DLL_CALLBACK JSEqualityOp)(JSContext *cx, JSObject *obj, jsval v,
531
(* JS_DLL_CALLBACK JSConcatenateOp)(JSContext *cx, JSObject *obj, jsval v,
534
/* Typedef for native functions called by the JS VM. */
537
(* JS_DLL_CALLBACK JSNative)(JSContext *cx, JSObject *obj, uintN argc,
538
jsval *argv, jsval *rval);
540
/* Callbacks and their arguments. */
542
typedef enum JSContextOp {
548
* The possible values for contextOp when the runtime calls the callback are:
549
* JSCONTEXT_NEW JS_NewContext succesfully created a new JSContext
550
* instance. The callback can initialize the instance as
551
* required. If the callback returns false, the instance
552
* will be destroyed and JS_NewContext returns null. In
553
* this case the callback is not called again.
554
* JSCONTEXT_DESTROY One of JS_DestroyContext* methods is called. The
555
* callback may perform its own cleanup and must always
557
* Any other value For future compatibility the callback must do nothing
558
* and return true in this case.
561
(* JS_DLL_CALLBACK JSContextCallback)(JSContext *cx, uintN contextOp);
563
typedef enum JSGCStatus {
571
(* JS_DLL_CALLBACK JSGCCallback)(JSContext *cx, JSGCStatus status);
574
(* JS_DLL_CALLBACK JSBranchCallback)(JSContext *cx, JSScript *script);
577
(* JS_DLL_CALLBACK JSErrorReporter)(JSContext *cx, const char *message,
578
JSErrorReport *report);
581
* Possible exception types. These types are part of a JSErrorFormatString
582
* structure. They define which error to throw in case of a runtime error.
583
* JSEXN_NONE marks an unthrowable error.
585
typedef enum JSExnType {
598
typedef struct JSErrorFormatString {
599
/* The error format string (UTF-8 if JS_C_STRINGS_ARE_UTF8 is defined). */
602
/* The number of arguments to expand in the formatted error message. */
605
/* One of the JSExnType constants above. */
607
} JSErrorFormatString;
609
typedef const JSErrorFormatString *
610
(* JS_DLL_CALLBACK JSErrorCallback)(void *userRef, const char *locale,
611
const uintN errorNumber);
614
#define JS_ARGUMENT_FORMATTER_DEFINED 1
617
(* JS_DLL_CALLBACK JSArgumentFormatter)(JSContext *cx, const char *format,
618
JSBool fromJS, jsval **vpp,
623
(* JS_DLL_CALLBACK JSLocaleToUpperCase)(JSContext *cx, JSString *src,
627
(* JS_DLL_CALLBACK JSLocaleToLowerCase)(JSContext *cx, JSString *src,
631
(* JS_DLL_CALLBACK JSLocaleCompare)(JSContext *cx,
632
JSString *src1, JSString *src2,
636
(* JS_DLL_CALLBACK JSLocaleToUnicode)(JSContext *cx, char *src, jsval *rval);
639
* Security protocol types.
641
typedef struct JSPrincipals JSPrincipals;
644
* XDR-encode or -decode a principals instance, based on whether xdr->mode is
645
* JSXDR_ENCODE, in which case *principalsp should be encoded; or JSXDR_DECODE,
646
* in which case implementations must return a held (via JSPRINCIPALS_HOLD),
647
* non-null *principalsp out parameter. Return true on success, false on any
648
* error, which the implementation must have reported.
651
(* JS_DLL_CALLBACK JSPrincipalsTranscoder)(JSXDRState *xdr,
652
JSPrincipals **principalsp);
655
* Return a weak reference to the principals associated with obj, possibly via
656
* the immutable parent chain leading from obj to a top-level container (e.g.,
657
* a window object in the DOM level 0). If there are no principals associated
658
* with obj, return null. Therefore null does not mean an error was reported;
659
* in no event should an error be reported or an exception be thrown by this
660
* callback's implementation.
662
typedef JSPrincipals *
663
(* JS_DLL_CALLBACK JSObjectPrincipalsFinder)(JSContext *cx, JSObject *obj);
667
#endif /* jspubtd_h___ */
added
removed
src/js/jspubtd.h
