![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jscntxt.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / include / mozilla / js|
Return to jscntxt.h CVS log | Up to [Synchronet] / sbbs / include / mozilla / js |
1.1 root 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 jscntxt_h___
41: #define jscntxt_h___
42: /*
43: * JS execution context.
44: */
45: #include "jsarena.h" /* Added by JSIFY */
46: #include "jsclist.h"
47: #include "jslong.h"
48: #include "jsatom.h"
49: #include "jsconfig.h"
50: #include "jsdhash.h"
51: #include "jsgc.h"
52: #include "jsinterp.h"
53: #include "jsobj.h"
54: #include "jsprvtd.h"
55: #include "jspubtd.h"
56: #include "jsregexp.h"
57:
58: JS_BEGIN_EXTERN_C
59:
60: typedef enum JSGCMode { JS_NO_GC, JS_MAYBE_GC, JS_FORCE_GC } JSGCMode;
61:
62: typedef enum JSRuntimeState {
63: JSRTS_DOWN,
64: JSRTS_LAUNCHING,
65: JSRTS_UP,
66: JSRTS_LANDING
67: } JSRuntimeState;
68:
69: typedef struct JSPropertyTreeEntry {
70: JSDHashEntryHdr hdr;
71: JSScopeProperty *child;
72: } JSPropertyTreeEntry;
73:
74: struct JSRuntime {
75: /* Runtime state, synchronized by the stateChange/gcLock condvar/lock. */
76: JSRuntimeState state;
77:
78: /* Garbage collector state, used by jsgc.c. */
79: JSArenaPool gcArenaPool;
80: JSDHashTable gcRootsHash;
81: JSDHashTable *gcLocksHash;
82: JSGCThing *gcFreeList;
83: jsrefcount gcKeepAtoms;
84: uint32 gcBytes;
85: uint32 gcLastBytes;
86: uint32 gcMaxBytes;
87: uint32 gcLevel;
88: uint32 gcNumber;
89: JSPackedBool gcPoke;
90: JSPackedBool gcRunning;
91: JSGCCallback gcCallback;
92: uint32 gcMallocBytes;
93: #ifdef JS_GCMETER
94: JSGCStats gcStats;
95: #endif
96:
97: /* Literal table maintained by jsatom.c functions. */
98: JSAtomState atomState;
99:
100: /* Random number generator state, used by jsmath.c. */
101: JSBool rngInitialized;
102: int64 rngMultiplier;
103: int64 rngAddend;
104: int64 rngMask;
105: int64 rngSeed;
106: jsdouble rngDscale;
107:
108: /* Well-known numbers held for use by this runtime's contexts. */
109: jsdouble *jsNaN;
110: jsdouble *jsNegativeInfinity;
111: jsdouble *jsPositiveInfinity;
112:
113: /* Empty string held for use by this runtime's contexts. */
114: JSString *emptyString;
115:
116: /* List of active contexts sharing this runtime; protected by gcLock. */
117: JSCList contextList;
118:
119: /* These are used for debugging -- see jsprvtd.h and jsdbgapi.h. */
120: JSTrapHandler interruptHandler;
121: void *interruptHandlerData;
122: JSNewScriptHook newScriptHook;
123: void *newScriptHookData;
124: JSDestroyScriptHook destroyScriptHook;
125: void *destroyScriptHookData;
126: JSTrapHandler debuggerHandler;
127: void *debuggerHandlerData;
128: JSSourceHandler sourceHandler;
129: void *sourceHandlerData;
130: JSInterpreterHook executeHook;
131: void *executeHookData;
132: JSInterpreterHook callHook;
133: void *callHookData;
134: JSObjectHook objectHook;
135: void *objectHookData;
136: JSTrapHandler throwHook;
137: void *throwHookData;
138: JSDebugErrorHook debugErrorHook;
139: void *debugErrorHookData;
140:
141: /* More debugging state, see jsdbgapi.c. */
142: JSCList trapList;
143: JSCList watchPointList;
144:
145: /* Weak links to properties, indexed by quickened get/set opcodes. */
146: /* XXX must come after JSCLists or MSVC alignment bug bites empty lists */
147: JSPropertyCache propertyCache;
148:
149: /* Client opaque pointer */
150: void *data;
151:
152: #ifdef JS_THREADSAFE
153: /* These combine to interlock the GC and new requests. */
154: PRLock *gcLock;
155: PRCondVar *gcDone;
156: PRCondVar *requestDone;
157: uint32 requestCount;
158: jsword gcThread;
159:
160: /* Lock and owning thread pointer for JS_LOCK_RUNTIME. */
161: PRLock *rtLock;
162: #ifdef DEBUG
163: jsword rtLockOwner;
164: #endif
165:
166: /* Used to synchronize down/up state change; protected by gcLock. */
167: PRCondVar *stateChange;
168:
169: /* Used to serialize cycle checks when setting __proto__ or __parent__. */
170: PRLock *setSlotLock;
171: PRCondVar *setSlotDone;
172: JSBool setSlotBusy;
173: JSScope *setSlotScope; /* deadlock avoidance, see jslock.c */
174:
175: /*
176: * State for sharing single-threaded scopes, once a second thread tries to
177: * lock a scope. The scopeSharingDone condvar is protected by rt->gcLock,
178: * to minimize number of locks taken in JS_EndRequest.
179: *
180: * The scopeSharingTodo linked list is likewise "global" per runtime, not
181: * one-list-per-context, to conserve space over all contexts, optimizing
182: * for the likely case that scopes become shared rarely, and among a very
183: * small set of threads (contexts).
184: */
185: PRCondVar *scopeSharingDone;
186: JSScope *scopeSharingTodo;
187:
188: /*
189: * Magic terminator for the rt->scopeSharingTodo linked list, threaded through
190: * scope->u.link. This hack allows us to test whether a scope is on the list
191: * by asking whether scope->u.link is non-null. We use a large, likely bogus
192: * pointer here to distinguish this value from any valid u.count (small int)
193: * value.
194: */
195: #define NO_SCOPE_SHARING_TODO ((JSScope *) 0xfeedbeef)
196: #endif /* JS_THREADSAFE */
197:
198: /*
199: * Check property accessibility for objects of arbitrary class. Used at
200: * present to check f.caller accessibility for any function object f.
201: */
202: JSCheckAccessOp checkObjectAccess;
203:
204: /* Security principals serialization support. */
205: JSPrincipalsTranscoder principalsTranscoder;
206:
207: /* Shared scope property tree, and allocator for its nodes. */
208: JSDHashTable propertyTreeHash;
209: JSScopeProperty *propertyFreeList;
210: JSArenaPool propertyArenaPool;
211:
212: /* Script filename table. */
213: struct JSHashTable *scriptFilenameTable;
214: #ifdef JS_THREADSAFE
215: PRLock *scriptFilenameTableLock;
216: #endif
217:
218: /* Number localization, used by jsnum.c */
219: const char *thousandsSeparator;
220: const char *decimalSeparator;
221: const char *numGrouping;
222:
223: #ifdef DEBUG
224: /* Function invocation metering. */
225: jsrefcount inlineCalls;
226: jsrefcount nativeCalls;
227: jsrefcount nonInlineCalls;
228: jsrefcount constructs;
229:
230: /* Scope lock and property metering. */
231: jsrefcount claimAttempts;
232: jsrefcount claimedScopes;
233: jsrefcount deadContexts;
234: jsrefcount deadlocksAvoided;
235: jsrefcount liveScopes;
236: jsrefcount sharedScopes;
237: jsrefcount totalScopes;
238: jsrefcount badUndependStrings;
239: jsrefcount liveScopeProps;
240: jsrefcount totalScopeProps;
241: jsrefcount livePropTreeNodes;
242: jsrefcount duplicatePropTreeNodes;
243: jsrefcount totalPropTreeNodes;
244: jsrefcount propTreeKidsChunks;
245: jsrefcount middleDeleteFixups;
246:
247: /* String instrumentation. */
248: jsrefcount liveStrings;
249: jsrefcount totalStrings;
250: jsrefcount liveDependentStrings;
251: jsrefcount totalDependentStrings;
252: double lengthSum;
253: double lengthSquaredSum;
254: double strdepLengthSum;
255: double strdepLengthSquaredSum;
256: #endif
257: };
258:
259: #ifdef DEBUG
260: # define JS_RUNTIME_METER(rt, which) JS_ATOMIC_INCREMENT(&(rt)->which)
261: # define JS_RUNTIME_UNMETER(rt, which) JS_ATOMIC_DECREMENT(&(rt)->which)
262: #else
263: # define JS_RUNTIME_METER(rt, which) /* nothing */
264: # define JS_RUNTIME_UNMETER(rt, which) /* nothing */
265: #endif
266:
267: #define JS_KEEP_ATOMS(rt) JS_ATOMIC_INCREMENT(&(rt)->gcKeepAtoms);
268: #define JS_UNKEEP_ATOMS(rt) JS_ATOMIC_DECREMENT(&(rt)->gcKeepAtoms);
269:
270: #ifdef JS_ARGUMENT_FORMATTER_DEFINED
271: /*
272: * Linked list mapping format strings for JS_{Convert,Push}Arguments{,VA} to
273: * formatter functions. Elements are sorted in non-increasing format string
274: * length order.
275: */
276: struct JSArgumentFormatMap {
277: const char *format;
278: size_t length;
279: JSArgumentFormatter formatter;
280: JSArgumentFormatMap *next;
281: };
282: #endif
283:
284: struct JSStackHeader {
285: uintN nslots;
286: JSStackHeader *down;
287: };
288:
289: #define JS_STACK_SEGMENT(sh) ((jsval *)(sh) + 2)
290:
291: /*
292: * Key and entry types for the JSContext.resolvingTable hash table, typedef'd
293: * here because all consumers need to see these declarations (and not just the
294: * typedef names, as would be the case for an opaque pointer-to-typedef'd-type
295: * declaration), along with cx->resolvingTable.
296: */
297: typedef struct JSResolvingKey {
298: JSObject *obj;
299: jsid id;
300: } JSResolvingKey;
301:
302: typedef struct JSResolvingEntry {
303: JSDHashEntryHdr hdr;
304: JSResolvingKey key;
305: uint32 flags;
306: } JSResolvingEntry;
307:
308: #define JSRESFLAG_LOOKUP 0x1 /* resolving id from lookup */
309: #define JSRESFLAG_WATCH 0x2 /* resolving id from watch */
310:
311: typedef struct JSLocalRootChunk JSLocalRootChunk;
312:
313: #define JSLRS_CHUNK_SHIFT 6
314: #define JSLRS_CHUNK_SIZE JS_BIT(JSLRS_CHUNK_SHIFT)
315: #define JSLRS_CHUNK_MASK JS_BITMASK(JSLRS_CHUNK_SHIFT)
316:
317: struct JSLocalRootChunk {
318: jsval roots[JSLRS_CHUNK_SIZE];
319: JSLocalRootChunk *down;
320: };
321:
322: typedef struct JSLocalRootStack {
323: uint16 scopeMark;
324: uint16 rootCount;
325: JSLocalRootChunk *topChunk;
326: JSLocalRootChunk firstChunk;
327: } JSLocalRootStack;
328:
329: #define JSLRS_NULL_MARK ((uint16) -1)
330:
331: struct JSContext {
332: JSCList links;
333:
334: /* Interpreter activation count. */
335: uintN interpLevel;
336:
337: /* Limit pointer for checking stack consumption during recursion. */
338: jsuword stackLimit;
339:
340: /* Runtime version control identifier and equality operators. */
341: JSVersion version;
342: jsbytecode jsop_eq;
343: jsbytecode jsop_ne;
344:
345: /* Data shared by threads in an address space. */
346: JSRuntime *runtime;
347:
348: /* Stack arena pool and frame pointer register. */
349: JSArenaPool stackPool;
350: JSStackFrame *fp;
351:
352: /* Temporary arena pool used while compiling and decompiling. */
353: JSArenaPool tempPool;
354:
355: /* Top-level object and pointer to top stack frame's scope chain. */
356: JSObject *globalObject;
357:
358: /* Most recently created things by type, members of the GC's root set. */
359: JSGCThing *newborn[GCX_NTYPES];
360:
361: /* Atom root for the last-looked-up atom on this context. */
362: JSAtom *lastAtom;
363:
364: /* Regular expression class statics (XXX not shared globally). */
365: JSRegExpStatics regExpStatics;
366:
367: /* State for object and array toSource conversion. */
368: JSSharpObjectMap sharpObjectMap;
369:
370: /* Argument formatter support for JS_{Convert,Push}Arguments{,VA}. */
371: JSArgumentFormatMap *argumentFormatMap;
372:
373: /* Last message string and trace file for debugging. */
374: char *lastMessage;
375: #ifdef DEBUG
376: void *tracefp;
377: #endif
378:
379: /* Per-context optional user callbacks. */
380: JSBranchCallback branchCallback;
381: JSErrorReporter errorReporter;
382:
383: /* Client opaque pointer */
384: void *data;
385:
386: /* GC and thread-safe state. */
387: JSStackFrame *dormantFrameChain; /* dormant stack frame to scan */
388: #ifdef JS_THREADSAFE
389: jsword thread;
390: jsrefcount requestDepth;
391: JSScope *scopeToShare; /* weak reference, see jslock.c */
392: JSScope *lockedSealedScope; /* weak ref, for low-cost sealed
393: scope locking */
394: #endif
395:
396: #if JS_HAS_LVALUE_RETURN
397: /*
398: * Secondary return value from native method called on the left-hand side
399: * of an assignment operator. The native should store the object in which
400: * to set a property in *rval, and return the property's id expressed as a
401: * jsval by calling JS_SetCallReturnValue2(cx, idval).
402: */
403: jsval rval2;
404: JSPackedBool rval2set;
405: #endif
406:
407: /*
408: * True if creating an exception object, to prevent runaway recursion.
409: * NB: creatingException packs with rval2set, #if JS_HAS_LVALUE_RETURN,
410: * and with throwing, below.
411: */
412: JSPackedBool creatingException;
413:
414: /*
415: * Exception state -- the exception member is a GC root by definition.
416: * NB: throwing packs with creatingException and rval2set, above.
417: */
418: JSPackedBool throwing; /* is there a pending exception? */
419: jsval exception; /* most-recently-thrown exception */
420:
421: /* Per-context options. */
422: uint32 options; /* see jsapi.h for JSOPTION_* */
423:
424: /* Locale specific callbacks for string conversion. */
425: JSLocaleCallbacks *localeCallbacks;
426:
427: /*
428: * cx->resolvingTable is non-null and non-empty if we are initializing
429: * standard classes lazily, or if we are otherwise recursing indirectly
430: * from js_LookupProperty through a JSClass.resolve hook. It is used to
431: * limit runaway recursion (see jsapi.c and jsobj.c).
432: */
433: JSDHashTable *resolvingTable;
434:
435: /* PDL of stack headers describing stack slots not rooted by argv, etc. */
436: JSStackHeader *stackHeaders;
437:
438: /* Optional hook to find principals for an object being accessed on cx. */
439: JSObjectPrincipalsFinder findObjectPrincipals;
440:
441: /* Optional stack of scoped local GC roots. */
442: JSLocalRootStack *localRootStack;
443: };
444:
445: /*
446: * Slightly more readable macros, also to hide bitset implementation detail.
447: * XXX beware non-boolean truth values, which belie the bitset hiding claim!
448: */
449: #define JS_HAS_STRICT_OPTION(cx) ((cx)->options & JSOPTION_STRICT)
450: #define JS_HAS_WERROR_OPTION(cx) ((cx)->options & JSOPTION_WERROR)
451: #define JS_HAS_COMPILE_N_GO_OPTION(cx) ((cx)->options & JSOPTION_COMPILE_N_GO)
452: #define JS_HAS_ATLINE_OPTION(cx) ((cx)->options & JSOPTION_ATLINE)
453:
454: extern JSContext *
455: js_NewContext(JSRuntime *rt, size_t stackChunkSize);
456:
457: extern void
458: js_DestroyContext(JSContext *cx, JSGCMode gcmode);
459:
460: /*
461: * Return true if cx points to a context in rt->contextList, else return false.
462: * NB: the caller (see jslock.c:ClaimScope) must hold rt->gcLock.
463: */
464: extern JSBool
465: js_ValidContextPointer(JSRuntime *rt, JSContext *cx);
466:
467: /*
468: * If unlocked, acquire and release rt->gcLock around *iterp update; otherwise
469: * the caller must be holding rt->gcLock.
470: */
471: extern JSContext *
472: js_ContextIterator(JSRuntime *rt, JSBool unlocked, JSContext **iterp);
473:
474: /*
475: * JSClass.resolve and watchpoint recursion damping machinery.
476: */
477: extern JSBool
478: js_StartResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
479: JSResolvingEntry **entryp);
480:
481: extern void
482: js_StopResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
483: JSResolvingEntry *entry, uint32 generation);
484:
485: /*
486: * Local root set management.
487: */
488: extern JSBool
489: js_EnterLocalRootScope(JSContext *cx);
490:
491: extern void
492: js_LeaveLocalRootScope(JSContext *cx);
493:
494: extern void
495: js_ForgetLocalRoot(JSContext *cx, jsval v);
496:
497: extern int
498: js_PushLocalRoot(JSContext *cx, JSLocalRootStack *lrs, jsval v);
499:
500: extern void
501: js_MarkLocalRoots(JSContext *cx, JSLocalRootStack *lrs);
502:
503: /*
504: * Report an exception, which is currently realized as a printf-style format
505: * string and its arguments.
506: */
507: typedef enum JSErrNum {
508: #define MSG_DEF(name, number, count, exception, format) \
509: name = number,
510: #include "js.msg"
511: #undef MSG_DEF
512: JSErr_Limit
513: } JSErrNum;
514:
515: extern const JSErrorFormatString *
516: js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber);
517:
518: #ifdef va_start
519: extern JSBool
520: js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap);
521:
522: extern JSBool
523: js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
524: void *userRef, const uintN errorNumber,
525: JSBool charArgs, va_list ap);
526:
527: extern JSBool
528: js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
529: void *userRef, const uintN errorNumber,
530: char **message, JSErrorReport *reportp,
531: JSBool *warningp, JSBool charArgs, va_list ap);
532: #endif
533:
534: extern void
535: js_ReportOutOfMemory(JSContext *cx, JSErrorCallback errorCallback);
536:
537: /*
538: * Report an exception using a previously composed JSErrorReport.
539: * XXXbe remove from "friend" API
540: */
541: extern JS_FRIEND_API(void)
542: js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *report);
543:
544: extern void
545: js_ReportIsNotDefined(JSContext *cx, const char *name);
546:
547: extern JSErrorFormatString js_ErrorFormatString[JSErr_Limit];
548:
549: /*
550: * See JS_SetThreadStackLimit in jsapi.c, where we check that the stack grows
551: * in the expected direction. On Unix-y systems, JS_STACK_GROWTH_DIRECTION is
552: * computed on the build host by jscpucfg.c and written into jsautocfg.h. The
553: * macro is hardcoded in jscpucfg.h on Windows and Mac systems (for historical
554: * reasons pre-dating autoconf usage).
555: */
556: #if JS_STACK_GROWTH_DIRECTION > 0
557: # define JS_CHECK_STACK_SIZE(cx, lval) ((jsuword)&(lval) < (cx)->stackLimit)
558: #else
559: # define JS_CHECK_STACK_SIZE(cx, lval) ((jsuword)&(lval) > (cx)->stackLimit)
560: #endif
561:
562: JS_END_EXTERN_C
563:
564: #endif /* jscntxt_h___ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.