![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jsatom.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 jsatom.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 jsatom_h___
41: #define jsatom_h___
42: /*
43: * JS atom table.
44: */
45: #include <stddef.h>
46: #include "jstypes.h"
47: #include "jshash.h" /* Added by JSIFY */
48: #include "jsapi.h"
49: #include "jsprvtd.h"
50: #include "jspubtd.h"
51:
52: #ifdef JS_THREADSAFE
53: #include "jslock.h"
54: #endif
55:
56: JS_BEGIN_EXTERN_C
57:
58: #define ATOM_PINNED 0x01 /* atom is pinned against GC */
59: #define ATOM_INTERNED 0x02 /* pinned variant for JS_Intern* API */
60: #define ATOM_MARK 0x04 /* atom is reachable via GC */
61: #define ATOM_NOCOPY 0x40 /* don't copy atom string bytes */
62: #define ATOM_TMPSTR 0x80 /* internal, to avoid extra string */
63:
64: struct JSAtom {
65: JSHashEntry entry; /* key is jsval, value keyword info */
66: uint32 flags; /* pinned, interned, and mark flags */
67: jsatomid number; /* atom serial number and hash code */
68: };
69:
70: #define ATOM_KEY(atom) ((jsval)(atom)->entry.key)
71: #define ATOM_IS_OBJECT(atom) JSVAL_IS_OBJECT(ATOM_KEY(atom))
72: #define ATOM_TO_OBJECT(atom) JSVAL_TO_OBJECT(ATOM_KEY(atom))
73: #define ATOM_IS_INT(atom) JSVAL_IS_INT(ATOM_KEY(atom))
74: #define ATOM_TO_INT(atom) JSVAL_TO_INT(ATOM_KEY(atom))
75: #define ATOM_IS_DOUBLE(atom) JSVAL_IS_DOUBLE(ATOM_KEY(atom))
76: #define ATOM_TO_DOUBLE(atom) JSVAL_TO_DOUBLE(ATOM_KEY(atom))
77: #define ATOM_IS_STRING(atom) JSVAL_IS_STRING(ATOM_KEY(atom))
78: #define ATOM_TO_STRING(atom) JSVAL_TO_STRING(ATOM_KEY(atom))
79: #define ATOM_IS_BOOLEAN(atom) JSVAL_IS_BOOLEAN(ATOM_KEY(atom))
80: #define ATOM_TO_BOOLEAN(atom) JSVAL_TO_BOOLEAN(ATOM_KEY(atom))
81:
82: /*
83: * Return a printable, lossless char[] representation of a string-type atom.
84: * The lifetime of the result extends at least until the next GC activation,
85: * longer if cx's string newborn root is not overwritten.
86: */
87: extern JS_FRIEND_API(const char *)
88: js_AtomToPrintableString(JSContext *cx, JSAtom *atom);
89:
90: #define ATOM_KEYWORD(atom) ((struct keyword *)(atom)->entry.value)
91: #define ATOM_SET_KEYWORD(atom,kw) ((atom)->entry.value = (kw))
92:
93: struct JSAtomListElement {
94: JSHashEntry entry;
95: };
96:
97: #define ALE_ATOM(ale) ((JSAtom *) (ale)->entry.key)
98: #define ALE_INDEX(ale) ((jsatomid) (ale)->entry.value)
99: #define ALE_JSOP(ale) ((JSOp) (ale)->entry.value)
100: #define ALE_VALUE(ale) ((jsval) (ale)->entry.value)
101: #define ALE_NEXT(ale) ((JSAtomListElement *) (ale)->entry.next)
102:
103: #define ALE_SET_ATOM(ale,atom) ((ale)->entry.key = (const void *)(atom))
104: #define ALE_SET_INDEX(ale,index)((ale)->entry.value = (void *)(index))
105: #define ALE_SET_JSOP(ale,op) ((ale)->entry.value = (void *)(op))
106: #define ALE_SET_VALUE(ale,val) ((ale)->entry.value = (JSHashEntry *)(val))
107: #define ALE_SET_NEXT(ale,link) ((ale)->entry.next = (JSHashEntry *)(link))
108:
109: struct JSAtomList {
110: JSAtomListElement *list; /* literals indexed for mapping */
111: JSHashTable *table; /* hash table if list gets too long */
112: jsuint count; /* count of indexed literals */
113: };
114:
115: #define ATOM_LIST_INIT(al) ((al)->list = NULL, (al)->table = NULL, \
116: (al)->count = 0)
117:
118: #define ATOM_LIST_SEARCH(_ale,_al,_atom) \
119: JS_BEGIN_MACRO \
120: JSHashEntry **_hep; \
121: ATOM_LIST_LOOKUP(_ale, _hep, _al, _atom); \
122: JS_END_MACRO
123:
124: #define ATOM_LIST_LOOKUP(_ale,_hep,_al,_atom) \
125: JS_BEGIN_MACRO \
126: if ((_al)->table) { \
127: _hep = JS_HashTableRawLookup((_al)->table, _atom->number, _atom); \
128: _ale = *_hep ? (JSAtomListElement *) *_hep : NULL; \
129: } else { \
130: JSAtomListElement **_alep = &(_al)->list; \
131: _hep = NULL; \
132: while ((_ale = *_alep) != NULL) { \
133: if (ALE_ATOM(_ale) == (_atom)) { \
134: /* Hit, move atom's element to the front of the list. */ \
135: *_alep = ALE_NEXT(_ale); \
136: ALE_SET_NEXT(_ale, (_al)->list); \
137: (_al)->list = _ale; \
138: break; \
139: } \
140: _alep = (JSAtomListElement **)&_ale->entry.next; \
141: } \
142: } \
143: JS_END_MACRO
144:
145: struct JSAtomMap {
146: JSAtom **vector; /* array of ptrs to indexed atoms */
147: jsatomid length; /* count of (to-be-)indexed atoms */
148: };
149:
150: struct JSAtomState {
151: JSRuntime *runtime; /* runtime that owns us */
152: JSHashTable *table; /* hash table containing all atoms */
153: jsatomid number; /* one beyond greatest atom number */
154: jsatomid liveAtoms; /* number of live atoms after last GC */
155:
156: /* Type names and value literals. */
157: JSAtom *typeAtoms[JSTYPE_LIMIT];
158: JSAtom *booleanAtoms[2];
159: JSAtom *nullAtom;
160:
161: /* Various built-in or commonly-used atoms, pinned on first context. */
162: JSAtom *ArgumentsAtom;
163: JSAtom *ArrayAtom;
164: JSAtom *BooleanAtom;
165: JSAtom *CallAtom;
166: JSAtom *DateAtom;
167: JSAtom *ErrorAtom;
168: JSAtom *FunctionAtom;
169: JSAtom *MathAtom;
170: JSAtom *NumberAtom;
171: JSAtom *ObjectAtom;
172: JSAtom *RegExpAtom;
173: JSAtom *ScriptAtom;
174: JSAtom *StringAtom;
175: JSAtom *anonymousAtom;
176: JSAtom *argumentsAtom;
177: JSAtom *arityAtom;
178: JSAtom *calleeAtom;
179: JSAtom *callerAtom;
180: JSAtom *classPrototypeAtom;
181: JSAtom *constructorAtom;
182: JSAtom *countAtom;
183: JSAtom *evalAtom;
184: JSAtom *getAtom;
185: JSAtom *getterAtom;
186: JSAtom *indexAtom;
187: JSAtom *inputAtom;
188: JSAtom *lengthAtom;
189: JSAtom *nameAtom;
190: JSAtom *noSuchMethodAtom;
191: JSAtom *parentAtom;
192: JSAtom *protoAtom;
193: JSAtom *setAtom;
194: JSAtom *setterAtom;
195: JSAtom *toLocaleStringAtom;
196: JSAtom *toSourceAtom;
197: JSAtom *toStringAtom;
198: JSAtom *valueOfAtom;
199:
200: /* Less frequently used atoms, pinned lazily by JS_ResolveStandardClass. */
201: struct {
202: JSAtom *EvalErrorAtom;
203: JSAtom *InfinityAtom;
204: JSAtom *InternalErrorAtom;
205: JSAtom *NaNAtom;
206: JSAtom *RangeErrorAtom;
207: JSAtom *ReferenceErrorAtom;
208: JSAtom *SyntaxErrorAtom;
209: JSAtom *TypeErrorAtom;
210: JSAtom *URIErrorAtom;
211: JSAtom *decodeURIAtom;
212: JSAtom *decodeURIComponentAtom;
213: JSAtom *defineGetterAtom;
214: JSAtom *defineSetterAtom;
215: JSAtom *encodeURIAtom;
216: JSAtom *encodeURIComponentAtom;
217: JSAtom *escapeAtom;
218: JSAtom *hasOwnPropertyAtom;
219: JSAtom *isFiniteAtom;
220: JSAtom *isNaNAtom;
221: JSAtom *isPrototypeOfAtom;
222: JSAtom *lookupGetterAtom;
223: JSAtom *lookupSetterAtom;
224: JSAtom *parseFloatAtom;
225: JSAtom *parseIntAtom;
226: JSAtom *propertyIsEnumerableAtom;
227: JSAtom *unescapeAtom;
228: JSAtom *unevalAtom;
229: JSAtom *unwatchAtom;
230: JSAtom *watchAtom;
231: } lazy;
232:
233: #ifdef JS_THREADSAFE
234: JSThinLock lock;
235: volatile uint32 tablegen;
236: #endif
237: #ifdef NARCISSUS
238: JSAtom *callAtom;
239: JSAtom *constructAtom;
240: JSAtom *hasInstanceAtom;
241: JSAtom *ExecutionContextAtom;
242: JSAtom *currentAtom;
243: #endif
244: };
245:
246: /* Well-known predefined strings and their atoms. */
247: extern const char *js_type_str[];
248: extern const char *js_boolean_str[];
249:
250: extern const char js_Arguments_str[];
251: extern const char js_Array_str[];
252: extern const char js_Boolean_str[];
253: extern const char js_Call_str[];
254: extern const char js_Date_str[];
255: extern const char js_Function_str[];
256: extern const char js_Math_str[];
257: extern const char js_Number_str[];
258: extern const char js_Object_str[];
259: extern const char js_RegExp_str[];
260: extern const char js_Script_str[];
261: extern const char js_String_str[];
262: extern const char js_anonymous_str[];
263: extern const char js_arguments_str[];
264: extern const char js_arity_str[];
265: extern const char js_callee_str[];
266: extern const char js_caller_str[];
267: extern const char js_class_prototype_str[];
268: extern const char js_constructor_str[];
269: extern const char js_count_str[];
270: extern const char js_eval_str[];
271: extern const char js_getter_str[];
272: extern const char js_get_str[];
273: extern const char js_index_str[];
274: extern const char js_input_str[];
275: extern const char js_length_str[];
276: extern const char js_name_str[];
277: extern const char js_noSuchMethod_str[];
278: extern const char js_parent_str[];
279: extern const char js_proto_str[];
280: extern const char js_setter_str[];
281: extern const char js_set_str[];
282: extern const char js_toSource_str[];
283: extern const char js_toString_str[];
284: extern const char js_toLocaleString_str[];
285: extern const char js_valueOf_str[];
286:
287: #ifdef NARCISSUS
288: extern const char js_call_str[];
289: extern const char js_construct_str[];
290: extern const char js_hasInstance_str[];
291: extern const char js_ExecutionContext_str[];
292: extern const char js_current_str[];
293: #endif
294:
295: /*
296: * Initialize atom state. Return true on success, false with an out of
297: * memory error report on failure.
298: */
299: extern JSBool
300: js_InitAtomState(JSContext *cx, JSAtomState *state);
301:
302: /*
303: * Free and clear atom state (except for any interned string atoms).
304: */
305: extern void
306: js_FreeAtomState(JSContext *cx, JSAtomState *state);
307:
308: /*
309: * Interned strings are atoms that live until state's runtime is destroyed.
310: * This function frees all interned string atoms, and then frees and clears
311: * state's members (just as js_FreeAtomState does), unless there aren't any
312: * interned strings in state -- in which case state must be "free" already.
313: *
314: * NB: js_FreeAtomState is called for each "last" context being destroyed in
315: * a runtime, where there may yet be another context created in the runtime;
316: * whereas js_FinishAtomState is called from JS_DestroyRuntime, when we know
317: * that no more contexts will be created. Thus we minimize garbage during
318: * context-free episodes on a runtime, while preserving atoms created by the
319: * JS_Intern*String APIs for the life of the runtime.
320: */
321: extern void
322: js_FinishAtomState(JSAtomState *state);
323:
324: /*
325: * Atom garbage collection hooks.
326: */
327: typedef void
328: (*JSGCThingMarker)(void *thing, void *data);
329:
330: extern void
331: js_MarkAtomState(JSAtomState *state, uintN gcflags, JSGCThingMarker mark,
332: void *data);
333:
334: extern void
335: js_SweepAtomState(JSAtomState *state);
336:
337: extern JSBool
338: js_InitPinnedAtoms(JSContext *cx, JSAtomState *state);
339:
340: extern void
341: js_UnpinPinnedAtoms(JSAtomState *state);
342:
343: /*
344: * Find or create the atom for an object. If we create a new atom, give it the
345: * type indicated in flags. Return 0 on failure to allocate memory.
346: */
347: extern JSAtom *
348: js_AtomizeObject(JSContext *cx, JSObject *obj, uintN flags);
349:
350: /*
351: * Find or create the atom for a Boolean value. If we create a new atom, give
352: * it the type indicated in flags. Return 0 on failure to allocate memory.
353: */
354: extern JSAtom *
355: js_AtomizeBoolean(JSContext *cx, JSBool b, uintN flags);
356:
357: /*
358: * Find or create the atom for an integer value. If we create a new atom, give
359: * it the type indicated in flags. Return 0 on failure to allocate memory.
360: */
361: extern JSAtom *
362: js_AtomizeInt(JSContext *cx, jsint i, uintN flags);
363:
364: /*
365: * Find or create the atom for a double value. If we create a new atom, give
366: * it the type indicated in flags. Return 0 on failure to allocate memory.
367: */
368: extern JSAtom *
369: js_AtomizeDouble(JSContext *cx, jsdouble d, uintN flags);
370:
371: /*
372: * Find or create the atom for a string. If we create a new atom, give it the
373: * type indicated in flags. Return 0 on failure to allocate memory.
374: */
375: extern JSAtom *
376: js_AtomizeString(JSContext *cx, JSString *str, uintN flags);
377:
378: extern JS_FRIEND_API(JSAtom *)
379: js_Atomize(JSContext *cx, const char *bytes, size_t length, uintN flags);
380:
381: extern JS_FRIEND_API(JSAtom *)
382: js_AtomizeChars(JSContext *cx, const jschar *chars, size_t length, uintN flags);
383:
384: /*
385: * This variant handles all value tag types.
386: */
387: extern JSAtom *
388: js_AtomizeValue(JSContext *cx, jsval value, uintN flags);
389:
390: /*
391: * Convert v to an atomized string.
392: */
393: extern JSAtom *
394: js_ValueToStringAtom(JSContext *cx, jsval v);
395:
396: /*
397: * Assign atom an index and insert it on al.
398: */
399: extern JSAtomListElement *
400: js_IndexAtom(JSContext *cx, JSAtom *atom, JSAtomList *al);
401:
402: /*
403: * Get the atom with index i from map.
404: */
405: extern JS_FRIEND_API(JSAtom *)
406: js_GetAtom(JSContext *cx, JSAtomMap *map, jsatomid i);
407:
408: /*
409: * For all unmapped atoms recorded in al, add a mapping from the atom's index
410: * to its address. The GC must not run until all indexed atoms in atomLists
411: * have been mapped by scripts connected to live objects (Function and Script
412: * class objects have scripts as/in their private data -- the GC knows about
413: * these two classes).
414: */
415: extern JS_FRIEND_API(JSBool)
416: js_InitAtomMap(JSContext *cx, JSAtomMap *map, JSAtomList *al);
417:
418: /*
419: * Free map->vector and clear map.
420: */
421: extern JS_FRIEND_API(void)
422: js_FreeAtomMap(JSContext *cx, JSAtomMap *map);
423:
424: JS_END_EXTERN_C
425:
426: #endif /* jsatom_h___ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.