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

Contents of /trunk/js/jspubtd.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 460 - (show annotations)
Sat Sep 26 23:15:22 2009 UTC (9 years, 8 months ago) by siliconforks
File MIME type: text/plain
File size: 22075 byte(s)
Upgrade to SpiderMonkey from Firefox 3.5.3.

1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2 *
3 * ***** BEGIN LICENSE BLOCK *****
4 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5 *
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/
10 *
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
14 * License.
15 *
16 * The Original Code is Mozilla Communicator client code, released
17 * March 31, 1998.
18 *
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.
23 *
24 * Contributor(s):
25 *
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.
37 *
38 * ***** END LICENSE BLOCK ***** */
39
40 #ifndef jspubtd_h___
41 #define jspubtd_h___
42 /*
43 * JS public API typedefs.
44 */
45 #include "jstypes.h"
46 #include "jscompat.h"
47
48 JS_BEGIN_EXTERN_C
49
50 /* Scalar typedefs. */
51 typedef uint16 jschar;
52 typedef int32 jsint;
53 typedef uint32 jsuint;
54 typedef float64 jsdouble;
55 typedef jsword jsval;
56 typedef jsword jsid;
57 typedef int32 jsrefcount; /* PRInt32 if JS_THREADSAFE, see jslock.h */
58
59 /*
60 * Run-time version enumeration. See jsversion.h for compile-time counterparts
61 * to these values that may be selected by the JS_VERSION macro, and tested by
62 * #if expressions.
63 */
64 typedef enum JSVersion {
65 JSVERSION_1_0 = 100,
66 JSVERSION_1_1 = 110,
67 JSVERSION_1_2 = 120,
68 JSVERSION_1_3 = 130,
69 JSVERSION_1_4 = 140,
70 JSVERSION_ECMA_3 = 148,
71 JSVERSION_1_5 = 150,
72 JSVERSION_1_6 = 160,
73 JSVERSION_1_7 = 170,
74 JSVERSION_1_8 = 180,
75 JSVERSION_DEFAULT = 0,
76 JSVERSION_UNKNOWN = -1,
77 JSVERSION_LATEST = JSVERSION_1_8
78 } JSVersion;
79
80 #define JSVERSION_IS_ECMA(version) \
81 ((version) == JSVERSION_DEFAULT || (version) >= JSVERSION_1_3)
82
83 /* Result of typeof operator enumeration. */
84 typedef enum JSType {
85 JSTYPE_VOID, /* undefined */
86 JSTYPE_OBJECT, /* object */
87 JSTYPE_FUNCTION, /* function */
88 JSTYPE_STRING, /* string */
89 JSTYPE_NUMBER, /* number */
90 JSTYPE_BOOLEAN, /* boolean */
91 JSTYPE_NULL, /* null */
92 JSTYPE_XML, /* xml object */
93 JSTYPE_LIMIT
94 } JSType;
95
96 /* Dense index into cached prototypes and class atoms for standard objects. */
97 typedef enum JSProtoKey {
98 #define JS_PROTO(name,code,init) JSProto_##name = code,
99 #include "jsproto.tbl"
100 #undef JS_PROTO
101 JSProto_LIMIT
102 } JSProtoKey;
103
104 /* JSObjectOps.checkAccess mode enumeration. */
105 typedef enum JSAccessMode {
106 JSACC_PROTO = 0, /* XXXbe redundant w.r.t. id */
107 JSACC_PARENT = 1, /* XXXbe redundant w.r.t. id */
108
109 /*
110 * enum value #2 formerly called JSACC_IMPORT,
111 * gap preserved for liveconnect ABI compatibility.
112 */
113
114 JSACC_WATCH = 3, /* a watchpoint on object foo for id 'bar' */
115 JSACC_READ = 4, /* a "get" of foo.bar */
116 JSACC_WRITE = 8, /* a "set" of foo.bar = baz */
117 JSACC_LIMIT
118 } JSAccessMode;
119
120 #define JSACC_TYPEMASK (JSACC_WRITE - 1)
121
122 /*
123 * This enum type is used to control the behavior of a JSObject property
124 * iterator function that has type JSNewEnumerate.
125 */
126 typedef enum JSIterateOp {
127 JSENUMERATE_INIT, /* Create new iterator state */
128 JSENUMERATE_NEXT, /* Iterate once */
129 JSENUMERATE_DESTROY /* Destroy iterator state */
130 } JSIterateOp;
131
132 /* Struct typedefs. */
133 typedef struct JSClass JSClass;
134 typedef struct JSExtendedClass JSExtendedClass;
135 typedef struct JSConstDoubleSpec JSConstDoubleSpec;
136 typedef struct JSContext JSContext;
137 typedef struct JSErrorReport JSErrorReport;
138 typedef struct JSFunction JSFunction;
139 typedef struct JSFunctionSpec JSFunctionSpec;
140 typedef struct JSTracer JSTracer;
141 typedef struct JSIdArray JSIdArray;
142 typedef struct JSPropertyDescriptor JSPropertyDescriptor;
143 typedef struct JSPropertySpec JSPropertySpec;
144 typedef struct JSObject JSObject;
145 typedef struct JSObjectMap JSObjectMap;
146 typedef struct JSObjectOps JSObjectOps;
147 typedef struct JSRuntime JSRuntime;
148 typedef struct JSRuntime JSTaskState; /* XXX deprecated name */
149 typedef struct JSScript JSScript;
150 typedef struct JSStackFrame JSStackFrame;
151 typedef struct JSString JSString;
152 typedef struct JSXDRState JSXDRState;
153 typedef struct JSExceptionState JSExceptionState;
154 typedef struct JSLocaleCallbacks JSLocaleCallbacks;
155 typedef struct JSSecurityCallbacks JSSecurityCallbacks;
156 typedef struct JSONParser JSONParser;
157
158 /* JSClass (and JSObjectOps where appropriate) function pointer typedefs. */
159
160 /*
161 * Add, delete, get or set a property named by id in obj. Note the jsval id
162 * type -- id may be a string (Unicode property identifier) or an int (element
163 * index). The *vp out parameter, on success, is the new property value after
164 * an add, get, or set. After a successful delete, *vp is JSVAL_FALSE iff
165 * obj[id] can't be deleted (because it's permanent).
166 */
167 typedef JSBool
168 (* JSPropertyOp)(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
169
170 /*
171 * This function type is used for callbacks that enumerate the properties of
172 * a JSObject. The behavior depends on the value of enum_op:
173 *
174 * JSENUMERATE_INIT
175 * A new, opaque iterator state should be allocated and stored in *statep.
176 * (You can use PRIVATE_TO_JSVAL() to tag the pointer to be stored).
177 *
178 * The number of properties that will be enumerated should be returned as
179 * an integer jsval in *idp, if idp is non-null, and provided the number of
180 * enumerable properties is known. If idp is non-null and the number of
181 * enumerable properties can't be computed in advance, *idp should be set
182 * to JSVAL_ZERO.
183 *
184 * JSENUMERATE_NEXT
185 * A previously allocated opaque iterator state is passed in via statep.
186 * Return the next jsid in the iteration using *idp. The opaque iterator
187 * state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
188 * if there are no properties left to enumerate.
189 *
190 * JSENUMERATE_DESTROY
191 * Destroy the opaque iterator state previously allocated in *statep by a
192 * call to this function when enum_op was JSENUMERATE_INIT.
193 *
194 * The return value is used to indicate success, with a value of JS_FALSE
195 * indicating failure.
196 */
197 typedef JSBool
198 (* JSNewEnumerateOp)(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
199 jsval *statep, jsid *idp);
200
201 /*
202 * The old-style JSClass.enumerate op should define all lazy properties not
203 * yet reflected in obj.
204 */
205 typedef JSBool
206 (* JSEnumerateOp)(JSContext *cx, JSObject *obj);
207
208 /*
209 * Resolve a lazy property named by id in obj by defining it directly in obj.
210 * Lazy properties are those reflected from some peer native property space
211 * (e.g., the DOM attributes for a given node reflected as obj) on demand.
212 *
213 * JS looks for a property in an object, and if not found, tries to resolve
214 * the given id. If resolve succeeds, the engine looks again in case resolve
215 * defined obj[id]. If no such property exists directly in obj, the process
216 * is repeated with obj's prototype, etc.
217 *
218 * NB: JSNewResolveOp provides a cheaper way to resolve lazy properties.
219 */
220 typedef JSBool
221 (* JSResolveOp)(JSContext *cx, JSObject *obj, jsval id);
222
223 /*
224 * Like JSResolveOp, but flags provide contextual information as follows:
225 *
226 * JSRESOLVE_QUALIFIED a qualified property id: obj.id or obj[id], not id
227 * JSRESOLVE_ASSIGNING obj[id] is on the left-hand side of an assignment
228 * JSRESOLVE_DETECTING 'if (o.p)...' or similar detection opcode sequence
229 * JSRESOLVE_DECLARING var, const, or function prolog declaration opcode
230 * JSRESOLVE_CLASSNAME class name used when constructing
231 *
232 * The *objp out parameter, on success, should be null to indicate that id
233 * was not resolved; and non-null, referring to obj or one of its prototypes,
234 * if id was resolved.
235 *
236 * This hook instead of JSResolveOp is called via the JSClass.resolve member
237 * if JSCLASS_NEW_RESOLVE is set in JSClass.flags.
238 *
239 * Setting JSCLASS_NEW_RESOLVE and JSCLASS_NEW_RESOLVE_GETS_START further
240 * extends this hook by passing in the starting object on the prototype chain
241 * via *objp. Thus a resolve hook implementation may define the property id
242 * being resolved in the object in which the id was first sought, rather than
243 * in a prototype object whose class led to the resolve hook being called.
244 *
245 * When using JSCLASS_NEW_RESOLVE_GETS_START, the resolve hook must therefore
246 * null *objp to signify "not resolved". With only JSCLASS_NEW_RESOLVE and no
247 * JSCLASS_NEW_RESOLVE_GETS_START, the hook can assume *objp is null on entry.
248 * This is not good practice, but enough existing hook implementations count
249 * on it that we can't break compatibility by passing the starting object in
250 * *objp without a new JSClass flag.
251 */
252 typedef JSBool
253 (* JSNewResolveOp)(JSContext *cx, JSObject *obj, jsval id, uintN flags,
254 JSObject **objp);
255
256 /*
257 * Convert obj to the given type, returning true with the resulting value in
258 * *vp on success, and returning false on error or exception.
259 */
260 typedef JSBool
261 (* JSConvertOp)(JSContext *cx, JSObject *obj, JSType type, jsval *vp);
262
263 /*
264 * Finalize obj, which the garbage collector has determined to be unreachable
265 * from other live objects or from GC roots. Obviously, finalizers must never
266 * store a reference to obj.
267 */
268 typedef void
269 (* JSFinalizeOp)(JSContext *cx, JSObject *obj);
270
271 /*
272 * Used by JS_AddExternalStringFinalizer and JS_RemoveExternalStringFinalizer
273 * to extend and reduce the set of string types finalized by the GC.
274 */
275 typedef void
276 (* JSStringFinalizeOp)(JSContext *cx, JSString *str);
277
278 /*
279 * The signature for JSClass.getObjectOps, used by JS_NewObject's internals
280 * to discover the set of high-level object operations to use for new objects
281 * of the given class. All native objects have a JSClass, which is stored as
282 * a private (int-tagged) pointer in obj slots. In contrast, all native and
283 * host objects have a JSObjectMap at obj->map, which may be shared among a
284 * number of objects, and which contains the JSObjectOps *ops pointer used to
285 * dispatch object operations from API calls.
286 *
287 * Thus JSClass (which pre-dates JSObjectOps in the API) provides a low-level
288 * interface to class-specific code and data, while JSObjectOps allows for a
289 * higher level of operation, which does not use the object's class except to
290 * find the class's JSObjectOps struct, by calling clasp->getObjectOps, and to
291 * finalize the object.
292 *
293 * If this seems backwards, that's because it is! API compatibility requires
294 * a JSClass *clasp parameter to JS_NewObject, etc. Most host objects do not
295 * need to implement the larger JSObjectOps, and can share the common JSScope
296 * code and data used by the native (js_ObjectOps, see jsobj.c) ops.
297 */
298 typedef JSObjectOps *
299 (* JSGetObjectOps)(JSContext *cx, JSClass *clasp);
300
301 /*
302 * JSClass.checkAccess type: check whether obj[id] may be accessed per mode,
303 * returning false on error/exception, true on success with obj[id]'s last-got
304 * value in *vp, and its attributes in *attrsp. As for JSPropertyOp above, id
305 * is either a string or an int jsval.
306 *
307 * See JSCheckAccessIdOp, below, for the JSObjectOps counterpart, which takes
308 * a jsid (a tagged int or aligned, unique identifier pointer) rather than a
309 * jsval. The native js_ObjectOps.checkAccess simply forwards to the object's
310 * clasp->checkAccess, so that both JSClass and JSObjectOps implementors may
311 * specialize access checks.
312 */
313 typedef JSBool
314 (* JSCheckAccessOp)(JSContext *cx, JSObject *obj, jsval id, JSAccessMode mode,
315 jsval *vp);
316
317 /*
318 * Encode or decode an object, given an XDR state record representing external
319 * data. See jsxdrapi.h.
320 */
321 typedef JSBool
322 (* JSXDRObjectOp)(JSXDRState *xdr, JSObject **objp);
323
324 /*
325 * Check whether v is an instance of obj. Return false on error or exception,
326 * true on success with JS_TRUE in *bp if v is an instance of obj, JS_FALSE in
327 * *bp otherwise.
328 */
329 typedef JSBool
330 (* JSHasInstanceOp)(JSContext *cx, JSObject *obj, jsval v, JSBool *bp);
331
332 /*
333 * Deprecated function type for JSClass.mark. All new code should define
334 * JSTraceOp instead to ensure the traversal of traceable things stored in
335 * the native structures.
336 */
337 typedef uint32
338 (* JSMarkOp)(JSContext *cx, JSObject *obj, void *arg);
339
340 /*
341 * Function type for trace operation of the class called to enumerate all
342 * traceable things reachable from obj's private data structure. For each such
343 * thing, a trace implementation must call
344 *
345 * JS_CallTracer(trc, thing, kind);
346 *
347 * or one of its convenience macros as described in jsapi.h.
348 *
349 * JSTraceOp implementation can assume that no other threads mutates object
350 * state. It must not change state of the object or corresponding native
351 * structures. The only exception for this rule is the case when the embedding
352 * needs a tight integration with GC. In that case the embedding can check if
353 * the traversal is a part of the marking phase through calling
354 * JS_IsGCMarkingTracer and apply a special code like emptying caches or
355 * marking its native structures.
356 *
357 * To define the tracer for a JSClass, the implementation must add
358 * JSCLASS_MARK_IS_TRACE to class flags and use JS_CLASS_TRACE(method)
359 * macro below to convert JSTraceOp to JSMarkOp when initializing or
360 * assigning JSClass.mark field.
361 */
362 typedef void
363 (* JSTraceOp)(JSTracer *trc, JSObject *obj);
364
365 #if defined __GNUC__ && __GNUC__ >= 4 && !defined __cplusplus
366 # define JS_CLASS_TRACE(method) \
367 (__builtin_types_compatible_p(JSTraceOp, __typeof(&(method))) \
368 ? (JSMarkOp)(method) \
369 : js_WrongTypeForClassTracer)
370
371 extern JSMarkOp js_WrongTypeForClassTracer;
372
373 #else
374 # define JS_CLASS_TRACE(method) ((JSMarkOp)(method))
375 #endif
376
377 /*
378 * Tracer callback, called for each traceable thing directly refrenced by a
379 * particular object or runtime structure. It is the callback responsibility
380 * to ensure the traversal of the full object graph via calling eventually
381 * JS_TraceChildren on the passed thing. In this case the callback must be
382 * prepared to deal with cycles in the traversal graph.
383 *
384 * kind argument is one of JSTRACE_OBJECT, JSTRACE_DOUBLE, JSTRACE_STRING or
385 * a tag denoting internal implementation-specific traversal kind. In the
386 * latter case the only operations on thing that the callback can do is to call
387 * JS_TraceChildren or DEBUG-only JS_PrintTraceThingInfo.
388 */
389 typedef void
390 (* JSTraceCallback)(JSTracer *trc, void *thing, uint32 kind);
391
392 /*
393 * DEBUG only callback that JSTraceOp implementation can provide to return
394 * a string describing the reference traced with JS_CallTracer.
395 */
396 #ifdef DEBUG
397 typedef void
398 (* JSTraceNamePrinter)(JSTracer *trc, char *buf, size_t bufsize);
399 #endif
400
401 /*
402 * The optional JSClass.reserveSlots hook allows a class to make computed
403 * per-instance object slots reservations, in addition to or instead of using
404 * JSCLASS_HAS_RESERVED_SLOTS(n) in the JSClass.flags initializer to reserve
405 * a constant-per-class number of slots. Implementations of this hook should
406 * return the number of slots to reserve, not including any reserved by using
407 * JSCLASS_HAS_RESERVED_SLOTS(n) in JSClass.flags.
408 *
409 * NB: called with obj locked by the JSObjectOps-specific mutual exclusion
410 * mechanism appropriate for obj, so don't nest other operations that might
411 * also lock obj.
412 */
413 typedef uint32
414 (* JSReserveSlotsOp)(JSContext *cx, JSObject *obj);
415
416 /* JSExtendedClass function pointer typedefs. */
417
418 typedef JSBool
419 (* JSEqualityOp)(JSContext *cx, JSObject *obj, jsval v, JSBool *bp);
420
421 /*
422 * A generic type for functions mapping an object to another object, or null
423 * if an error or exception was thrown on cx. Used by JSObjectOps.thisObject
424 * at present.
425 */
426 typedef JSObject *
427 (* JSObjectOp)(JSContext *cx, JSObject *obj);
428
429 /*
430 * Hook that creates an iterator object for a given object. Returns the
431 * iterator object or null if an error or exception was thrown on cx.
432 */
433 typedef JSObject *
434 (* JSIteratorOp)(JSContext *cx, JSObject *obj, JSBool keysonly);
435
436 /* Typedef for native functions called by the JS VM. */
437
438 typedef JSBool
439 (* JSNative)(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
440 jsval *rval);
441
442 /* See jsapi.h, the JS_CALLEE, JS_THIS, etc. macros. */
443 typedef JSBool
444 (* JSFastNative)(JSContext *cx, uintN argc, jsval *vp);
445
446 /* Callbacks and their arguments. */
447
448 typedef enum JSContextOp {
449 JSCONTEXT_NEW,
450 JSCONTEXT_DESTROY
451 } JSContextOp;
452
453 /*
454 * The possible values for contextOp when the runtime calls the callback are:
455 * JSCONTEXT_NEW JS_NewContext successfully created a new JSContext
456 * instance. The callback can initialize the instance as
457 * required. If the callback returns false, the instance
458 * will be destroyed and JS_NewContext returns null. In
459 * this case the callback is not called again.
460 * JSCONTEXT_DESTROY One of JS_DestroyContext* methods is called. The
461 * callback may perform its own cleanup and must always
462 * return true.
463 * Any other value For future compatibility the callback must do nothing
464 * and return true in this case.
465 */
466 typedef JSBool
467 (* JSContextCallback)(JSContext *cx, uintN contextOp);
468
469 #ifndef JS_THREADSAFE
470 typedef void
471 (* JSHeartbeatCallback)(JSRuntime *rt);
472 #endif
473
474 typedef enum JSGCStatus {
475 JSGC_BEGIN,
476 JSGC_END,
477 JSGC_MARK_END,
478 JSGC_FINALIZE_END
479 } JSGCStatus;
480
481 typedef JSBool
482 (* JSGCCallback)(JSContext *cx, JSGCStatus status);
483
484 /*
485 * Generic trace operation that calls JS_CallTracer on each traceable thing
486 * stored in data.
487 */
488 typedef void
489 (* JSTraceDataOp)(JSTracer *trc, void *data);
490
491 typedef JSBool
492 (* JSOperationCallback)(JSContext *cx);
493
494 /*
495 * Deprecated form of JSOperationCallback.
496 */
497 typedef JSBool
498 (* JSBranchCallback)(JSContext *cx, JSScript *script);
499
500 typedef void
501 (* JSErrorReporter)(JSContext *cx, const char *message, JSErrorReport *report);
502
503 /*
504 * Possible exception types. These types are part of a JSErrorFormatString
505 * structure. They define which error to throw in case of a runtime error.
506 * JSEXN_NONE marks an unthrowable error.
507 */
508 typedef enum JSExnType {
509 JSEXN_NONE = -1,
510 JSEXN_ERR,
511 JSEXN_INTERNALERR,
512 JSEXN_EVALERR,
513 JSEXN_RANGEERR,
514 JSEXN_REFERENCEERR,
515 JSEXN_SYNTAXERR,
516 JSEXN_TYPEERR,
517 JSEXN_URIERR,
518 JSEXN_LIMIT
519 } JSExnType;
520
521 typedef struct JSErrorFormatString {
522 /* The error format string (UTF-8 if js_CStringsAreUTF8). */
523 const char *format;
524
525 /* The number of arguments to expand in the formatted error message. */
526 uint16 argCount;
527
528 /* One of the JSExnType constants above. */
529 int16 exnType;
530 } JSErrorFormatString;
531
532 typedef const JSErrorFormatString *
533 (* JSErrorCallback)(void *userRef, const char *locale,
534 const uintN errorNumber);
535
536 #ifdef va_start
537 #define JS_ARGUMENT_FORMATTER_DEFINED 1
538
539 typedef JSBool
540 (* JSArgumentFormatter)(JSContext *cx, const char *format, JSBool fromJS,
541 jsval **vpp, va_list *app);
542 #endif
543
544 typedef JSBool
545 (* JSLocaleToUpperCase)(JSContext *cx, JSString *src, jsval *rval);
546
547 typedef JSBool
548 (* JSLocaleToLowerCase)(JSContext *cx, JSString *src, jsval *rval);
549
550 typedef JSBool
551 (* JSLocaleCompare)(JSContext *cx, JSString *src1, JSString *src2,
552 jsval *rval);
553
554 typedef JSBool
555 (* JSLocaleToUnicode)(JSContext *cx, char *src, jsval *rval);
556
557 /*
558 * Security protocol types.
559 */
560 typedef struct JSPrincipals JSPrincipals;
561
562 /*
563 * XDR-encode or -decode a principals instance, based on whether xdr->mode is
564 * JSXDR_ENCODE, in which case *principalsp should be encoded; or JSXDR_DECODE,
565 * in which case implementations must return a held (via JSPRINCIPALS_HOLD),
566 * non-null *principalsp out parameter. Return true on success, false on any
567 * error, which the implementation must have reported.
568 */
569 typedef JSBool
570 (* JSPrincipalsTranscoder)(JSXDRState *xdr, JSPrincipals **principalsp);
571
572 /*
573 * Return a weak reference to the principals associated with obj, possibly via
574 * the immutable parent chain leading from obj to a top-level container (e.g.,
575 * a window object in the DOM level 0). If there are no principals associated
576 * with obj, return null. Therefore null does not mean an error was reported;
577 * in no event should an error be reported or an exception be thrown by this
578 * callback's implementation.
579 */
580 typedef JSPrincipals *
581 (* JSObjectPrincipalsFinder)(JSContext *cx, JSObject *obj);
582
583 JS_END_EXTERN_C
584
585 #endif /* jspubtd_h___ */

  ViewVC Help
Powered by ViewVC 1.1.24