PageRenderTime 127ms CodeModel.GetById 57ms app.highlight 54ms RepoModel.GetById 1ms app.codeStats 1ms

/js/lib/Socket.IO-node/support/expresso/deps/jscoverage/js/jscntxt.h

http://github.com/onedayitwillmake/RealtimeMultiplayerNodeJs
C++ Header | 1247 lines | 611 code | 199 blank | 437 comment | 10 complexity | af93b785bab04c6f2f80b2c3388dfb27 MD5 | raw file
   1/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2 * vim: set ts=8 sw=4 et tw=78:
   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 jscntxt_h___
  42#define jscntxt_h___
  43/*
  44 * JS execution context.
  45 */
  46#include "jsarena.h" /* Added by JSIFY */
  47#include "jsclist.h"
  48#include "jslong.h"
  49#include "jsatom.h"
  50#include "jsversion.h"
  51#include "jsdhash.h"
  52#include "jsgc.h"
  53#include "jsinterp.h"
  54#include "jsobj.h"
  55#include "jsprvtd.h"
  56#include "jspubtd.h"
  57#include "jsregexp.h"
  58#include "jsutil.h"
  59
  60JS_BEGIN_EXTERN_C
  61
  62/*
  63 * js_GetSrcNote cache to avoid O(n^2) growth in finding a source note for a
  64 * given pc in a script. We use the script->code pointer to tag the cache,
  65 * instead of the script address itself, so that source notes are always found
  66 * by offset from the bytecode with which they were generated.
  67 */
  68typedef struct JSGSNCache {
  69    jsbytecode      *code;
  70    JSDHashTable    table;
  71#ifdef JS_GSNMETER
  72    uint32          hits;
  73    uint32          misses;
  74    uint32          fills;
  75    uint32          clears;
  76# define GSN_CACHE_METER(cache,cnt) (++(cache)->cnt)
  77#else
  78# define GSN_CACHE_METER(cache,cnt) /* nothing */
  79#endif
  80} JSGSNCache;
  81
  82#define GSN_CACHE_CLEAR(cache)                                                \
  83    JS_BEGIN_MACRO                                                            \
  84        (cache)->code = NULL;                                                 \
  85        if ((cache)->table.ops) {                                             \
  86            JS_DHashTableFinish(&(cache)->table);                             \
  87            (cache)->table.ops = NULL;                                        \
  88        }                                                                     \
  89        GSN_CACHE_METER(cache, clears);                                       \
  90    JS_END_MACRO
  91
  92/* These helper macros take a cx as parameter and operate on its GSN cache. */
  93#define JS_CLEAR_GSN_CACHE(cx)      GSN_CACHE_CLEAR(&JS_GSN_CACHE(cx))
  94#define JS_METER_GSN_CACHE(cx,cnt)  GSN_CACHE_METER(&JS_GSN_CACHE(cx), cnt)
  95
  96#ifdef __cplusplus
  97namespace nanojit {
  98    class Fragment;
  99    class Fragmento;
 100}
 101class TraceRecorder;
 102extern "C++" { template<typename T> class Queue; }
 103typedef Queue<uint16> SlotList;
 104class TypeMap;
 105
 106# define CLS(T)  T*
 107#else
 108# define CLS(T)  void*
 109#endif
 110
 111/*
 112 * Trace monitor. Every JSThread (if JS_THREADSAFE) or JSRuntime (if not
 113 * JS_THREADSAFE) has an associated trace monitor that keeps track of loop
 114 * frequencies for all JavaScript code loaded into that runtime.
 115 */
 116typedef struct JSTraceMonitor {
 117    /*
 118     * Flag set when running (or recording) JIT-compiled code. This prevents
 119     * both interpreter activation and last-ditch garbage collection when up
 120     * against our runtime's memory limits. This flag also suppresses calls to
 121     * JS_ReportOutOfMemory when failing due to runtime limits.
 122     */
 123    JSBool                  onTrace;
 124    CLS(nanojit::Fragmento) fragmento;
 125    CLS(TraceRecorder)      recorder;
 126    uint32                  globalShape;
 127    CLS(SlotList)           globalSlots;
 128    CLS(TypeMap)            globalTypeMap;
 129    jsval                   *recoveryDoublePool;
 130    jsval                   *recoveryDoublePoolPtr;
 131
 132    /* Fragmento for the regular expression compiler. This is logically
 133     * a distinct compiler but needs to be managed in exactly the same
 134     * way as the real tracing Fragmento. */
 135    CLS(nanojit::Fragmento) reFragmento;
 136
 137    /* Keep a list of recorders we need to abort on cache flush. */
 138    CLS(TraceRecorder)      abortStack;
 139} JSTraceMonitor;
 140
 141#ifdef JS_TRACER
 142# define JS_ON_TRACE(cx)   (JS_TRACE_MONITOR(cx).onTrace)
 143#else
 144# define JS_ON_TRACE(cx)   JS_FALSE
 145#endif
 146
 147#ifdef JS_THREADSAFE
 148
 149/*
 150 * Structure uniquely representing a thread.  It holds thread-private data
 151 * that can be accessed without a global lock.
 152 */
 153struct JSThread {
 154    /* Linked list of all contexts active on this thread. */
 155    JSCList             contextList;
 156
 157    /* Opaque thread-id, from NSPR's PR_GetCurrentThread(). */
 158    jsword              id;
 159
 160    /*
 161     * Thread-local version of JSRuntime.gcMallocBytes to avoid taking
 162     * locks on each JS_malloc.
 163     */
 164    uint32              gcMallocBytes;
 165
 166    /*
 167     * Store the GSN cache in struct JSThread, not struct JSContext, both to
 168     * save space and to simplify cleanup in js_GC.  Any embedding (Firefox
 169     * or another Gecko application) that uses many contexts per thread is
 170     * unlikely to interleave js_GetSrcNote-intensive loops in the decompiler
 171     * among two or more contexts running script in one thread.
 172     */
 173    JSGSNCache          gsnCache;
 174
 175    /* Property cache for faster call/get/set invocation. */
 176    JSPropertyCache     propertyCache;
 177
 178    /* Trace-tree JIT recorder/interpreter state. */
 179    JSTraceMonitor      traceMonitor;
 180
 181    /* Lock-free list of scripts created by eval to garbage-collect. */
 182    JSScript            *scriptsToGC;
 183};
 184
 185#define JS_GSN_CACHE(cx)        ((cx)->thread->gsnCache)
 186#define JS_PROPERTY_CACHE(cx)   ((cx)->thread->propertyCache)
 187#define JS_TRACE_MONITOR(cx)    ((cx)->thread->traceMonitor)
 188#define JS_SCRIPTS_TO_GC(cx)    ((cx)->thread->scriptsToGC)
 189
 190extern void
 191js_ThreadDestructorCB(void *ptr);
 192
 193extern JSBool
 194js_SetContextThread(JSContext *cx);
 195
 196extern void
 197js_ClearContextThread(JSContext *cx);
 198
 199extern JSThread *
 200js_GetCurrentThread(JSRuntime *rt);
 201
 202#endif /* JS_THREADSAFE */
 203
 204typedef enum JSDestroyContextMode {
 205    JSDCM_NO_GC,
 206    JSDCM_MAYBE_GC,
 207    JSDCM_FORCE_GC,
 208    JSDCM_NEW_FAILED
 209} JSDestroyContextMode;
 210
 211typedef enum JSRuntimeState {
 212    JSRTS_DOWN,
 213    JSRTS_LAUNCHING,
 214    JSRTS_UP,
 215    JSRTS_LANDING
 216} JSRuntimeState;
 217
 218typedef struct JSPropertyTreeEntry {
 219    JSDHashEntryHdr     hdr;
 220    JSScopeProperty     *child;
 221} JSPropertyTreeEntry;
 222
 223typedef struct JSSetSlotRequest JSSetSlotRequest;
 224
 225struct JSSetSlotRequest {
 226    JSObject            *obj;           /* object containing slot to set */
 227    JSObject            *pobj;          /* new proto or parent reference */
 228    uint16              slot;           /* which to set, proto or parent */
 229    uint16              errnum;         /* JSMSG_NO_ERROR or error result */
 230    JSSetSlotRequest    *next;          /* next request in GC worklist */
 231};
 232
 233struct JSRuntime {
 234    /* Runtime state, synchronized by the stateChange/gcLock condvar/lock. */
 235    JSRuntimeState      state;
 236
 237    /* Context create/destroy callback. */
 238    JSContextCallback   cxCallback;
 239
 240    /* Garbage collector state, used by jsgc.c. */
 241    JSGCChunkInfo       *gcChunkList;
 242    JSGCArenaList       gcArenaList[GC_NUM_FREELISTS];
 243    JSGCDoubleArenaList gcDoubleArenaList;
 244    JSGCFreeListSet     *gcFreeListsPool;
 245    JSDHashTable        gcRootsHash;
 246    JSDHashTable        *gcLocksHash;
 247    jsrefcount          gcKeepAtoms;
 248    uint32              gcBytes;
 249    uint32              gcLastBytes;
 250    uint32              gcMaxBytes;
 251    uint32              gcMaxMallocBytes;
 252    uint32              gcEmptyArenaPoolLifespan;
 253    uint32              gcLevel;
 254    uint32              gcNumber;
 255    JSTracer            *gcMarkingTracer;
 256
 257    /*
 258     * NB: do not pack another flag here by claiming gcPadding unless the new
 259     * flag is written only by the GC thread.  Atomic updates to packed bytes
 260     * are not guaranteed, so stores issued by one thread may be lost due to
 261     * unsynchronized read-modify-write cycles on other threads.
 262     */
 263    JSPackedBool        gcPoke;
 264    JSPackedBool        gcRunning;
 265    uint16              gcPadding;
 266#ifdef JS_GC_ZEAL
 267    jsrefcount          gcZeal;
 268#endif
 269
 270    JSGCCallback        gcCallback;
 271    uint32              gcMallocBytes;
 272    JSGCArenaInfo       *gcUntracedArenaStackTop;
 273#ifdef DEBUG
 274    size_t              gcTraceLaterCount;
 275#endif
 276
 277    /*
 278     * Table for tracking iterators to ensure that we close iterator's state
 279     * before finalizing the iterable object.
 280     */
 281    JSPtrTable          gcIteratorTable;
 282
 283    /*
 284     * The trace operation and its data argument to trace embedding-specific
 285     * GC roots.
 286     */
 287    JSTraceDataOp       gcExtraRootsTraceOp;
 288    void                *gcExtraRootsData;
 289
 290    /*
 291     * Used to serialize cycle checks when setting __proto__ or __parent__ by
 292     * requesting the GC handle the required cycle detection. If the GC hasn't
 293     * been poked, it won't scan for garbage. This member is protected by
 294     * rt->gcLock.
 295     */
 296    JSSetSlotRequest    *setSlotRequests;
 297
 298    /* Random number generator state, used by jsmath.c. */
 299    JSBool              rngInitialized;
 300    int64               rngMultiplier;
 301    int64               rngAddend;
 302    int64               rngMask;
 303    int64               rngSeed;
 304    jsdouble            rngDscale;
 305
 306    /* Well-known numbers held for use by this runtime's contexts. */
 307    jsdouble            *jsNaN;
 308    jsdouble            *jsNegativeInfinity;
 309    jsdouble            *jsPositiveInfinity;
 310
 311#ifdef JS_THREADSAFE
 312    JSLock              *deflatedStringCacheLock;
 313#endif
 314    JSHashTable         *deflatedStringCache;
 315#ifdef DEBUG
 316    uint32              deflatedStringCacheBytes;
 317#endif
 318
 319    /*
 320     * Empty and unit-length strings held for use by this runtime's contexts.
 321     * The unitStrings array and its elements are created on demand.
 322     */
 323    JSString            *emptyString;
 324    JSString            **unitStrings;
 325
 326    /* List of active contexts sharing this runtime; protected by gcLock. */
 327    JSCList             contextList;
 328
 329    /* Per runtime debug hooks -- see jsprvtd.h and jsdbgapi.h. */
 330    JSDebugHooks        globalDebugHooks;
 331
 332    /* More debugging state, see jsdbgapi.c. */
 333    JSCList             trapList;
 334    JSCList             watchPointList;
 335
 336    /* Client opaque pointers */
 337    void                *data;
 338
 339#ifdef JS_THREADSAFE
 340    /* These combine to interlock the GC and new requests. */
 341    PRLock              *gcLock;
 342    PRCondVar           *gcDone;
 343    PRCondVar           *requestDone;
 344    uint32              requestCount;
 345    JSThread            *gcThread;
 346
 347    /* Lock and owning thread pointer for JS_LOCK_RUNTIME. */
 348    PRLock              *rtLock;
 349#ifdef DEBUG
 350    jsword              rtLockOwner;
 351#endif
 352
 353    /* Used to synchronize down/up state change; protected by gcLock. */
 354    PRCondVar           *stateChange;
 355
 356    /*
 357     * State for sharing single-threaded titles, once a second thread tries to
 358     * lock a title.  The titleSharingDone condvar is protected by rt->gcLock
 359     * to minimize number of locks taken in JS_EndRequest.
 360     *
 361     * The titleSharingTodo linked list is likewise "global" per runtime, not
 362     * one-list-per-context, to conserve space over all contexts, optimizing
 363     * for the likely case that titles become shared rarely, and among a very
 364     * small set of threads (contexts).
 365     */
 366    PRCondVar           *titleSharingDone;
 367    JSTitle             *titleSharingTodo;
 368
 369/*
 370 * Magic terminator for the rt->titleSharingTodo linked list, threaded through
 371 * title->u.link.  This hack allows us to test whether a title is on the list
 372 * by asking whether title->u.link is non-null.  We use a large, likely bogus
 373 * pointer here to distinguish this value from any valid u.count (small int)
 374 * value.
 375 */
 376#define NO_TITLE_SHARING_TODO   ((JSTitle *) 0xfeedbeef)
 377
 378    /*
 379     * Lock serializing trapList and watchPointList accesses, and count of all
 380     * mutations to trapList and watchPointList made by debugger threads.  To
 381     * keep the code simple, we define debuggerMutations for the thread-unsafe
 382     * case too.
 383     */
 384    PRLock              *debuggerLock;
 385#endif /* JS_THREADSAFE */
 386    uint32              debuggerMutations;
 387
 388    /*
 389     * Security callbacks set on the runtime are used by each context unless
 390     * an override is set on the context.
 391     */
 392    JSSecurityCallbacks *securityCallbacks;
 393
 394    /*
 395     * Shared scope property tree, and arena-pool for allocating its nodes.
 396     * The propertyRemovals counter is incremented for every js_ClearScope,
 397     * and for each js_RemoveScopeProperty that frees a slot in an object.
 398     * See js_NativeGet and js_NativeSet in jsobj.c.
 399     */
 400    JSDHashTable        propertyTreeHash;
 401    JSScopeProperty     *propertyFreeList;
 402    JSArenaPool         propertyArenaPool;
 403    int32               propertyRemovals;
 404
 405    /* Script filename table. */
 406    struct JSHashTable  *scriptFilenameTable;
 407    JSCList             scriptFilenamePrefixes;
 408#ifdef JS_THREADSAFE
 409    PRLock              *scriptFilenameTableLock;
 410#endif
 411
 412    /* Number localization, used by jsnum.c */
 413    const char          *thousandsSeparator;
 414    const char          *decimalSeparator;
 415    const char          *numGrouping;
 416
 417    /*
 418     * Weak references to lazily-created, well-known XML singletons.
 419     *
 420     * NB: Singleton objects must be carefully disconnected from the rest of
 421     * the object graph usually associated with a JSContext's global object,
 422     * including the set of standard class objects.  See jsxml.c for details.
 423     */
 424    JSObject            *anynameObject;
 425    JSObject            *functionNamespaceObject;
 426
 427    /*
 428     * A helper list for the GC, so it can mark native iterator states. See
 429     * js_TraceNativeEnumerators for details.
 430     */
 431    JSNativeEnumerator  *nativeEnumerators;
 432
 433#ifndef JS_THREADSAFE
 434    /*
 435     * For thread-unsafe embeddings, the GSN cache lives in the runtime and
 436     * not each context, since we expect it to be filled once when decompiling
 437     * a longer script, then hit repeatedly as js_GetSrcNote is called during
 438     * the decompiler activation that filled it.
 439     */
 440    JSGSNCache          gsnCache;
 441
 442    /* Property cache for faster call/get/set invocation. */
 443    JSPropertyCache     propertyCache;
 444
 445    /* Trace-tree JIT recorder/interpreter state. */
 446    JSTraceMonitor      traceMonitor;
 447
 448    /* Lock-free list of scripts created by eval to garbage-collect. */
 449    JSScript            *scriptsToGC;
 450
 451#define JS_GSN_CACHE(cx)        ((cx)->runtime->gsnCache)
 452#define JS_PROPERTY_CACHE(cx)   ((cx)->runtime->propertyCache)
 453#define JS_TRACE_MONITOR(cx)    ((cx)->runtime->traceMonitor)
 454#define JS_SCRIPTS_TO_GC(cx)    ((cx)->runtime->scriptsToGC)
 455#endif
 456
 457    /*
 458     * Object shape (property cache structural type) identifier generator.
 459     *
 460     * Type 0 stands for the empty scope, and must not be regenerated due to
 461     * uint32 wrap-around. Since we use atomic pre-increment, the initial
 462     * value for the first typed non-empty scope will be 1.
 463     *
 464     * The GC compresses live types, minimizing rt->shapeGen in the process.
 465     * If this counter overflows into SHAPE_OVERFLOW_BIT (in jsinterp.h), the
 466     * GC will disable property caches for all threads, to avoid aliasing two
 467     * different types. Updated by js_GenerateShape (in jsinterp.c).
 468     */
 469    uint32              shapeGen;
 470
 471    /* Literal table maintained by jsatom.c functions. */
 472    JSAtomState         atomState;
 473
 474    /*
 475     * Cache of reusable JSNativeEnumerators mapped by shape identifiers (as
 476     * stored in scope->shape). This cache is nulled by the GC and protected
 477     * by gcLock.
 478     */
 479#define NATIVE_ENUM_CACHE_LOG2  8
 480#define NATIVE_ENUM_CACHE_MASK  JS_BITMASK(NATIVE_ENUM_CACHE_LOG2)
 481#define NATIVE_ENUM_CACHE_SIZE  JS_BIT(NATIVE_ENUM_CACHE_LOG2)
 482
 483#define NATIVE_ENUM_CACHE_HASH(shape)                                         \
 484    ((((shape) >> NATIVE_ENUM_CACHE_LOG2) ^ (shape)) & NATIVE_ENUM_CACHE_MASK)
 485
 486    jsuword             nativeEnumCache[NATIVE_ENUM_CACHE_SIZE];
 487
 488    /*
 489     * Runtime-wide flag set to true when any Array prototype has an indexed
 490     * property defined on it, creating a hazard for code reading or writing
 491     * over a hole from a dense Array instance that is not prepared to look up
 492     * the proto chain (the writing case must involve a check for a read-only
 493     * element, which cannot be shadowed).
 494     */
 495    JSBool              anyArrayProtoHasElement;
 496
 497    /*
 498     * Various metering fields are defined at the end of JSRuntime. In this
 499     * way there is no need to recompile all the code that refers to other
 500     * fields of JSRuntime after enabling the corresponding metering macro.
 501     */
 502#ifdef JS_DUMP_ENUM_CACHE_STATS
 503    int32               nativeEnumProbes;
 504    int32               nativeEnumMisses;
 505# define ENUM_CACHE_METER(name)     JS_ATOMIC_INCREMENT(&cx->runtime->name)
 506#else
 507# define ENUM_CACHE_METER(name)     ((void) 0)
 508#endif
 509
 510#ifdef JS_DUMP_LOOP_STATS
 511    /* Loop statistics, to trigger trace recording and compiling. */
 512    JSBasicStats        loopStats;
 513#endif
 514
 515#if defined DEBUG || defined JS_DUMP_PROPTREE_STATS
 516    /* Function invocation metering. */
 517    jsrefcount          inlineCalls;
 518    jsrefcount          nativeCalls;
 519    jsrefcount          nonInlineCalls;
 520    jsrefcount          constructs;
 521
 522    /* Title lock and scope property metering. */
 523    jsrefcount          claimAttempts;
 524    jsrefcount          claimedTitles;
 525    jsrefcount          deadContexts;
 526    jsrefcount          deadlocksAvoided;
 527    jsrefcount          liveScopes;
 528    jsrefcount          sharedTitles;
 529    jsrefcount          totalScopes;
 530    jsrefcount          liveScopeProps;
 531    jsrefcount          liveScopePropsPreSweep;
 532    jsrefcount          totalScopeProps;
 533    jsrefcount          livePropTreeNodes;
 534    jsrefcount          duplicatePropTreeNodes;
 535    jsrefcount          totalPropTreeNodes;
 536    jsrefcount          propTreeKidsChunks;
 537    jsrefcount          middleDeleteFixups;
 538
 539    /* String instrumentation. */
 540    jsrefcount          liveStrings;
 541    jsrefcount          totalStrings;
 542    jsrefcount          liveDependentStrings;
 543    jsrefcount          totalDependentStrings;
 544    jsrefcount          badUndependStrings;
 545    double              lengthSum;
 546    double              lengthSquaredSum;
 547    double              strdepLengthSum;
 548    double              strdepLengthSquaredSum;
 549#endif /* DEBUG || JS_DUMP_PROPTREE_STATS */
 550
 551#ifdef JS_SCOPE_DEPTH_METER
 552    /*
 553     * Stats on runtime prototype chain lookups and scope chain depths, i.e.,
 554     * counts of objects traversed on a chain until the wanted id is found.
 555     */
 556    JSBasicStats        protoLookupDepthStats;
 557    JSBasicStats        scopeSearchDepthStats;
 558
 559    /*
 560     * Stats on compile-time host environment and lexical scope chain lengths
 561     * (maximum depths).
 562     */
 563    JSBasicStats        hostenvScopeDepthStats;
 564    JSBasicStats        lexicalScopeDepthStats;
 565#endif
 566
 567#ifdef JS_GCMETER
 568    JSGCStats           gcStats;
 569#endif
 570};
 571
 572#ifdef DEBUG
 573# define JS_RUNTIME_METER(rt, which)    JS_ATOMIC_INCREMENT(&(rt)->which)
 574# define JS_RUNTIME_UNMETER(rt, which)  JS_ATOMIC_DECREMENT(&(rt)->which)
 575#else
 576# define JS_RUNTIME_METER(rt, which)    /* nothing */
 577# define JS_RUNTIME_UNMETER(rt, which)  /* nothing */
 578#endif
 579
 580#define JS_KEEP_ATOMS(rt)   JS_ATOMIC_INCREMENT(&(rt)->gcKeepAtoms);
 581#define JS_UNKEEP_ATOMS(rt) JS_ATOMIC_DECREMENT(&(rt)->gcKeepAtoms);
 582
 583#ifdef JS_ARGUMENT_FORMATTER_DEFINED
 584/*
 585 * Linked list mapping format strings for JS_{Convert,Push}Arguments{,VA} to
 586 * formatter functions.  Elements are sorted in non-increasing format string
 587 * length order.
 588 */
 589struct JSArgumentFormatMap {
 590    const char          *format;
 591    size_t              length;
 592    JSArgumentFormatter formatter;
 593    JSArgumentFormatMap *next;
 594};
 595#endif
 596
 597struct JSStackHeader {
 598    uintN               nslots;
 599    JSStackHeader       *down;
 600};
 601
 602#define JS_STACK_SEGMENT(sh)    ((jsval *)(sh) + 2)
 603
 604/*
 605 * Key and entry types for the JSContext.resolvingTable hash table, typedef'd
 606 * here because all consumers need to see these declarations (and not just the
 607 * typedef names, as would be the case for an opaque pointer-to-typedef'd-type
 608 * declaration), along with cx->resolvingTable.
 609 */
 610typedef struct JSResolvingKey {
 611    JSObject            *obj;
 612    jsid                id;
 613} JSResolvingKey;
 614
 615typedef struct JSResolvingEntry {
 616    JSDHashEntryHdr     hdr;
 617    JSResolvingKey      key;
 618    uint32              flags;
 619} JSResolvingEntry;
 620
 621#define JSRESFLAG_LOOKUP        0x1     /* resolving id from lookup */
 622#define JSRESFLAG_WATCH         0x2     /* resolving id from watch */
 623
 624typedef struct JSLocalRootChunk JSLocalRootChunk;
 625
 626#define JSLRS_CHUNK_SHIFT       8
 627#define JSLRS_CHUNK_SIZE        JS_BIT(JSLRS_CHUNK_SHIFT)
 628#define JSLRS_CHUNK_MASK        JS_BITMASK(JSLRS_CHUNK_SHIFT)
 629
 630struct JSLocalRootChunk {
 631    jsval               roots[JSLRS_CHUNK_SIZE];
 632    JSLocalRootChunk    *down;
 633};
 634
 635typedef struct JSLocalRootStack {
 636    uint32              scopeMark;
 637    uint32              rootCount;
 638    JSLocalRootChunk    *topChunk;
 639    JSLocalRootChunk    firstChunk;
 640} JSLocalRootStack;
 641
 642#define JSLRS_NULL_MARK ((uint32) -1)
 643
 644/*
 645 * Macros to push/pop JSTempValueRooter instances to context-linked stack of
 646 * temporary GC roots. If you need to protect a result value that flows out of
 647 * a C function across several layers of other functions, use the
 648 * js_LeaveLocalRootScopeWithResult internal API (see further below) instead.
 649 *
 650 * The macros also provide a simple way to get a single rooted pointer via
 651 * JS_PUSH_TEMP_ROOT_<KIND>(cx, NULL, &tvr). Then &tvr.u.<kind> gives the
 652 * necessary pointer.
 653 *
 654 * JSTempValueRooter.count defines the type of the rooted value referenced by
 655 * JSTempValueRooter.u union of type JSTempValueUnion. When count is positive
 656 * or zero, u.array points to a vector of jsvals. Otherwise it must be one of
 657 * the following constants:
 658 */
 659#define JSTVU_SINGLE        (-1)    /* u.value or u.<gcthing> is single jsval
 660                                       or GC-thing */
 661#define JSTVU_TRACE         (-2)    /* u.trace is a hook to trace a custom
 662                                     * structure */
 663#define JSTVU_SPROP         (-3)    /* u.sprop roots property tree node */
 664#define JSTVU_WEAK_ROOTS    (-4)    /* u.weakRoots points to saved weak roots */
 665#define JSTVU_PARSE_CONTEXT (-5)    /* u.parseContext roots JSParseContext* */
 666#define JSTVU_SCRIPT        (-6)    /* u.script roots JSScript* */
 667
 668/*
 669 * Here single JSTVU_SINGLE covers both jsval and pointers to any GC-thing via
 670 * reinterpreting the thing as JSVAL_OBJECT. It works because the GC-thing is
 671 * aligned on a 0 mod 8 boundary, and object has the 0 jsval tag. So any
 672 * GC-thing may be tagged as if it were an object and untagged, if it's then
 673 * used only as an opaque pointer until discriminated by other means than tag
 674 * bits. This is how, for example, js_GetGCThingTraceKind uses its |thing|
 675 * parameter -- it consults GC-thing flags stored separately from the thing to
 676 * decide the kind of thing.
 677 *
 678 * The following checks that this type-punning is possible.
 679 */
 680JS_STATIC_ASSERT(sizeof(JSTempValueUnion) == sizeof(jsval));
 681JS_STATIC_ASSERT(sizeof(JSTempValueUnion) == sizeof(void *));
 682
 683#define JS_PUSH_TEMP_ROOT_COMMON(cx,x,tvr,cnt,kind)                           \
 684    JS_BEGIN_MACRO                                                            \
 685        JS_ASSERT((cx)->tempValueRooters != (tvr));                           \
 686        (tvr)->count = (cnt);                                                 \
 687        (tvr)->u.kind = (x);                                                  \
 688        (tvr)->down = (cx)->tempValueRooters;                                 \
 689        (cx)->tempValueRooters = (tvr);                                       \
 690    JS_END_MACRO
 691
 692#define JS_POP_TEMP_ROOT(cx,tvr)                                              \
 693    JS_BEGIN_MACRO                                                            \
 694        JS_ASSERT((cx)->tempValueRooters == (tvr));                           \
 695        (cx)->tempValueRooters = (tvr)->down;                                 \
 696    JS_END_MACRO
 697
 698#define JS_PUSH_TEMP_ROOT(cx,cnt,arr,tvr)                                     \
 699    JS_BEGIN_MACRO                                                            \
 700        JS_ASSERT((int)(cnt) >= 0);                                           \
 701        JS_PUSH_TEMP_ROOT_COMMON(cx, arr, tvr, (ptrdiff_t) (cnt), array);     \
 702    JS_END_MACRO
 703
 704#define JS_PUSH_SINGLE_TEMP_ROOT(cx,val,tvr)                                  \
 705    JS_PUSH_TEMP_ROOT_COMMON(cx, val, tvr, JSTVU_SINGLE, value)
 706
 707#define JS_PUSH_TEMP_ROOT_OBJECT(cx,obj,tvr)                                  \
 708    JS_PUSH_TEMP_ROOT_COMMON(cx, obj, tvr, JSTVU_SINGLE, object)
 709
 710#define JS_PUSH_TEMP_ROOT_STRING(cx,str,tvr)                                  \
 711    JS_PUSH_TEMP_ROOT_COMMON(cx, str, tvr, JSTVU_SINGLE, string)
 712
 713#define JS_PUSH_TEMP_ROOT_XML(cx,xml_,tvr)                                    \
 714    JS_PUSH_TEMP_ROOT_COMMON(cx, xml_, tvr, JSTVU_SINGLE, xml)
 715
 716#define JS_PUSH_TEMP_ROOT_TRACE(cx,trace_,tvr)                                \
 717    JS_PUSH_TEMP_ROOT_COMMON(cx, trace_, tvr, JSTVU_TRACE, trace)
 718
 719#define JS_PUSH_TEMP_ROOT_SPROP(cx,sprop_,tvr)                                \
 720    JS_PUSH_TEMP_ROOT_COMMON(cx, sprop_, tvr, JSTVU_SPROP, sprop)
 721
 722#define JS_PUSH_TEMP_ROOT_WEAK_COPY(cx,weakRoots_,tvr)                        \
 723    JS_PUSH_TEMP_ROOT_COMMON(cx, weakRoots_, tvr, JSTVU_WEAK_ROOTS, weakRoots)
 724
 725#define JS_PUSH_TEMP_ROOT_PARSE_CONTEXT(cx,pc,tvr)                            \
 726    JS_PUSH_TEMP_ROOT_COMMON(cx, pc, tvr, JSTVU_PARSE_CONTEXT, parseContext)
 727
 728#define JS_PUSH_TEMP_ROOT_SCRIPT(cx,script_,tvr)                              \
 729    JS_PUSH_TEMP_ROOT_COMMON(cx, script_, tvr, JSTVU_SCRIPT, script)
 730
 731
 732#define JSRESOLVE_INFER         0xffff  /* infer bits from current bytecode */
 733
 734struct JSContext {
 735    /* JSRuntime contextList linkage. */
 736    JSCList             links;
 737
 738    /*
 739     * Operation count. It is declared early in the structure as a frequently
 740     * accessed field.
 741     */
 742    int32               operationCount;
 743
 744#if JS_HAS_XML_SUPPORT
 745    /*
 746     * Bit-set formed from binary exponentials of the XML_* tiny-ids defined
 747     * for boolean settings in jsxml.c, plus an XSF_CACHE_VALID bit.  Together
 748     * these act as a cache of the boolean XML.ignore* and XML.prettyPrinting
 749     * property values associated with this context's global object.
 750     */
 751    uint8               xmlSettingFlags;
 752    uint8               padding;
 753#else
 754    uint16              padding;
 755#endif
 756
 757    /*
 758     * Classic Algol "display" static link optimization.
 759     */
 760#define JS_DISPLAY_SIZE 16
 761
 762    JSStackFrame        *display[JS_DISPLAY_SIZE];
 763
 764    /* Runtime version control identifier. */
 765    uint16              version;
 766
 767    /* Per-context options. */
 768    uint32              options;            /* see jsapi.h for JSOPTION_* */
 769
 770    /* Locale specific callbacks for string conversion. */
 771    JSLocaleCallbacks   *localeCallbacks;
 772
 773    /*
 774     * cx->resolvingTable is non-null and non-empty if we are initializing
 775     * standard classes lazily, or if we are otherwise recursing indirectly
 776     * from js_LookupProperty through a JSClass.resolve hook.  It is used to
 777     * limit runaway recursion (see jsapi.c and jsobj.c).
 778     */
 779    JSDHashTable        *resolvingTable;
 780
 781#if JS_HAS_LVALUE_RETURN
 782    /*
 783     * Secondary return value from native method called on the left-hand side
 784     * of an assignment operator.  The native should store the object in which
 785     * to set a property in *rval, and return the property's id expressed as a
 786     * jsval by calling JS_SetCallReturnValue2(cx, idval).
 787     */
 788    jsval               rval2;
 789    JSPackedBool        rval2set;
 790#endif
 791
 792    /*
 793     * True if generating an error, to prevent runaway recursion.
 794     * NB: generatingError packs with rval2set, #if JS_HAS_LVALUE_RETURN;
 795     * with insideGCMarkCallback and with throwing below.
 796     */
 797    JSPackedBool        generatingError;
 798
 799    /* Flag to indicate that we run inside gcCallback(cx, JSGC_MARK_END). */
 800    JSPackedBool        insideGCMarkCallback;
 801
 802    /* Exception state -- the exception member is a GC root by definition. */
 803    JSPackedBool        throwing;           /* is there a pending exception? */
 804    jsval               exception;          /* most-recently-thrown exception */
 805
 806    /* Limit pointer for checking native stack consumption during recursion. */
 807    jsuword             stackLimit;
 808
 809    /* Quota on the size of arenas used to compile and execute scripts. */
 810    size_t              scriptStackQuota;
 811
 812    /* Data shared by threads in an address space. */
 813    JSRuntime           *runtime;
 814
 815    /* Stack arena pool and frame pointer register. */
 816    JSArenaPool         stackPool;
 817    JSStackFrame        *fp;
 818
 819    /* Temporary arena pool used while compiling and decompiling. */
 820    JSArenaPool         tempPool;
 821
 822    /* Top-level object and pointer to top stack frame's scope chain. */
 823    JSObject            *globalObject;
 824
 825    /* Storage to root recently allocated GC things and script result. */
 826    JSWeakRoots         weakRoots;
 827
 828    /* Regular expression class statics (XXX not shared globally). */
 829    JSRegExpStatics     regExpStatics;
 830
 831    /* State for object and array toSource conversion. */
 832    JSSharpObjectMap    sharpObjectMap;
 833
 834    /* Argument formatter support for JS_{Convert,Push}Arguments{,VA}. */
 835    JSArgumentFormatMap *argumentFormatMap;
 836
 837    /* Last message string and trace file for debugging. */
 838    char                *lastMessage;
 839#ifdef DEBUG
 840    void                *tracefp;
 841#endif
 842
 843    /* Per-context optional error reporter. */
 844    JSErrorReporter     errorReporter;
 845
 846    /*
 847     * Flag indicating that the operation callback is set. When the flag is 0
 848     * but operationCallback is not null, operationCallback stores the branch
 849     * callback.
 850     */
 851    uint32              operationCallbackIsSet :    1;
 852    uint32              operationLimit         :    31;
 853    JSOperationCallback operationCallback;
 854
 855    /* Interpreter activation count. */
 856    uintN               interpLevel;
 857
 858    /* Client opaque pointers. */
 859    void                *data;
 860    void                *data2;
 861
 862    /* GC and thread-safe state. */
 863    JSStackFrame        *dormantFrameChain; /* dormant stack frame to scan */
 864#ifdef JS_THREADSAFE
 865    JSThread            *thread;
 866    jsrefcount          requestDepth;
 867    /* Same as requestDepth but ignoring JS_SuspendRequest/JS_ResumeRequest */
 868    jsrefcount          outstandingRequests;
 869    JSTitle             *titleToShare;      /* weak reference, see jslock.c */
 870    JSTitle             *lockedSealedTitle; /* weak ref, for low-cost sealed
 871                                               title locking */
 872    JSCList             threadLinks;        /* JSThread contextList linkage */
 873
 874#define CX_FROM_THREAD_LINKS(tl) \
 875    ((JSContext *)((char *)(tl) - offsetof(JSContext, threadLinks)))
 876#endif
 877
 878    /* PDL of stack headers describing stack slots not rooted by argv, etc. */
 879    JSStackHeader       *stackHeaders;
 880
 881    /* Optional stack of heap-allocated scoped local GC roots. */
 882    JSLocalRootStack    *localRootStack;
 883
 884    /* Stack of thread-stack-allocated temporary GC roots. */
 885    JSTempValueRooter   *tempValueRooters;
 886
 887#ifdef JS_THREADSAFE
 888    JSGCFreeListSet     *gcLocalFreeLists;
 889#endif
 890
 891    /* List of pre-allocated doubles. */
 892    JSGCDoubleCell      *doubleFreeList;
 893
 894    /* Debug hooks associated with the current context. */
 895    JSDebugHooks        *debugHooks;
 896
 897    /* Security callbacks that override any defined on the runtime. */
 898    JSSecurityCallbacks *securityCallbacks;
 899
 900    /* Pinned regexp pool used for regular expressions. */
 901    JSArenaPool         regexpPool;
 902
 903    /* Stored here to avoid passing it around as a parameter. */
 904    uintN               resolveFlags;
 905};
 906
 907#ifdef JS_THREADSAFE
 908# define JS_THREAD_ID(cx)       ((cx)->thread ? (cx)->thread->id : 0)
 909#endif
 910
 911#ifdef __cplusplus
 912/* FIXME(bug 332648): Move this into a public header. */
 913class JSAutoTempValueRooter
 914{
 915  public:
 916    JSAutoTempValueRooter(JSContext *cx, size_t len, jsval *vec)
 917        : mContext(cx) {
 918        JS_PUSH_TEMP_ROOT(mContext, len, vec, &mTvr);
 919    }
 920    JSAutoTempValueRooter(JSContext *cx, jsval v)
 921        : mContext(cx) {
 922        JS_PUSH_SINGLE_TEMP_ROOT(mContext, v, &mTvr);
 923    }
 924
 925    ~JSAutoTempValueRooter() {
 926        JS_POP_TEMP_ROOT(mContext, &mTvr);
 927    }
 928
 929  protected:
 930    JSContext *mContext;
 931
 932  private:
 933#ifndef AIX
 934    static void *operator new(size_t);
 935    static void operator delete(void *, size_t);
 936#endif
 937
 938    JSTempValueRooter mTvr;
 939};
 940
 941class JSAutoResolveFlags
 942{
 943  public:
 944    JSAutoResolveFlags(JSContext *cx, uintN flags)
 945        : mContext(cx), mSaved(cx->resolveFlags) {
 946        cx->resolveFlags = flags;
 947    }
 948
 949    ~JSAutoResolveFlags() { mContext->resolveFlags = mSaved; }
 950
 951  private:
 952    JSContext *mContext;
 953    uintN mSaved;
 954};
 955#endif
 956
 957/*
 958 * Slightly more readable macros for testing per-context option settings (also
 959 * to hide bitset implementation detail).
 960 *
 961 * JSOPTION_XML must be handled specially in order to propagate from compile-
 962 * to run-time (from cx->options to script->version/cx->version).  To do that,
 963 * we copy JSOPTION_XML from cx->options into cx->version as JSVERSION_HAS_XML
 964 * whenever options are set, and preserve this XML flag across version number
 965 * changes done via the JS_SetVersion API.
 966 *
 967 * But when executing a script or scripted function, the interpreter changes
 968 * cx->version, including the XML flag, to script->version.  Thus JSOPTION_XML
 969 * is a compile-time option that causes a run-time version change during each
 970 * activation of the compiled script.  That version change has the effect of
 971 * changing JS_HAS_XML_OPTION, so that any compiling done via eval enables XML
 972 * support.  If an XML-enabled script or function calls a non-XML function,
 973 * the flag bit will be cleared during the callee's activation.
 974 *
 975 * Note that JS_SetVersion API calls never pass JSVERSION_HAS_XML or'd into
 976 * that API's version parameter.
 977 *
 978 * Note also that script->version must contain this XML option flag in order
 979 * for XDR'ed scripts to serialize and deserialize with that option preserved
 980 * for detection at run-time.  We can't copy other compile-time options into
 981 * script->version because that would break backward compatibility (certain
 982 * other options, e.g. JSOPTION_VAROBJFIX, are analogous to JSOPTION_XML).
 983 */
 984#define JS_HAS_OPTION(cx,option)        (((cx)->options & (option)) != 0)
 985#define JS_HAS_STRICT_OPTION(cx)        JS_HAS_OPTION(cx, JSOPTION_STRICT)
 986#define JS_HAS_WERROR_OPTION(cx)        JS_HAS_OPTION(cx, JSOPTION_WERROR)
 987#define JS_HAS_COMPILE_N_GO_OPTION(cx)  JS_HAS_OPTION(cx, JSOPTION_COMPILE_N_GO)
 988#define JS_HAS_ATLINE_OPTION(cx)        JS_HAS_OPTION(cx, JSOPTION_ATLINE)
 989
 990#define JSVERSION_MASK                  0x0FFF  /* see JSVersion in jspubtd.h */
 991#define JSVERSION_HAS_XML               0x1000  /* flag induced by XML option */
 992
 993#define JSVERSION_NUMBER(cx)            ((JSVersion)((cx)->version &          \
 994                                                     JSVERSION_MASK))
 995#define JS_HAS_XML_OPTION(cx)           ((cx)->version & JSVERSION_HAS_XML || \
 996                                         JSVERSION_NUMBER(cx) >= JSVERSION_1_6)
 997
 998/*
 999 * Initialize a library-wide thread private data index, and remember that it
1000 * has already been done, so that it happens only once ever.  Returns true on
1001 * success.
1002 */
1003extern JSBool
1004js_InitThreadPrivateIndex(void (*ptr)(void *));
1005
1006/*
1007 * Common subroutine of JS_SetVersion and js_SetVersion, to update per-context
1008 * data that depends on version.
1009 */
1010extern void
1011js_OnVersionChange(JSContext *cx);
1012
1013/*
1014 * Unlike the JS_SetVersion API, this function stores JSVERSION_HAS_XML and
1015 * any future non-version-number flags induced by compiler options.
1016 */
1017extern void
1018js_SetVersion(JSContext *cx, JSVersion version);
1019
1020/*
1021 * Create and destroy functions for JSContext, which is manually allocated
1022 * and exclusively owned.
1023 */
1024extern JSContext *
1025js_NewContext(JSRuntime *rt, size_t stackChunkSize);
1026
1027extern void
1028js_DestroyContext(JSContext *cx, JSDestroyContextMode mode);
1029
1030/*
1031 * Return true if cx points to a context in rt->contextList, else return false.
1032 * NB: the caller (see jslock.c:ClaimTitle) must hold rt->gcLock.
1033 */
1034extern JSBool
1035js_ValidContextPointer(JSRuntime *rt, JSContext *cx);
1036
1037/*
1038 * If unlocked, acquire and release rt->gcLock around *iterp update; otherwise
1039 * the caller must be holding rt->gcLock.
1040 */
1041extern JSContext *
1042js_ContextIterator(JSRuntime *rt, JSBool unlocked, JSContext **iterp);
1043
1044/*
1045 * JSClass.resolve and watchpoint recursion damping machinery.
1046 */
1047extern JSBool
1048js_StartResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
1049                  JSResolvingEntry **entryp);
1050
1051extern void
1052js_StopResolving(JSContext *cx, JSResolvingKey *key, uint32 flag,
1053                 JSResolvingEntry *entry, uint32 generation);
1054
1055/*
1056 * Local root set management.
1057 *
1058 * NB: the jsval parameters below may be properly tagged jsvals, or GC-thing
1059 * pointers cast to (jsval).  This relies on JSObject's tag being zero, but
1060 * on the up side it lets us push int-jsval-encoded scopeMark values on the
1061 * local root stack.
1062 */
1063extern JSBool
1064js_EnterLocalRootScope(JSContext *cx);
1065
1066#define js_LeaveLocalRootScope(cx) \
1067    js_LeaveLocalRootScopeWithResult(cx, JSVAL_NULL)
1068
1069extern void
1070js_LeaveLocalRootScopeWithResult(JSContext *cx, jsval rval);
1071
1072extern void
1073js_ForgetLocalRoot(JSContext *cx, jsval v);
1074
1075extern int
1076js_PushLocalRoot(JSContext *cx, JSLocalRootStack *lrs, jsval v);
1077
1078extern void
1079js_TraceLocalRoots(JSTracer *trc, JSLocalRootStack *lrs);
1080
1081/*
1082 * Report an exception, which is currently realized as a printf-style format
1083 * string and its arguments.
1084 */
1085typedef enum JSErrNum {
1086#define MSG_DEF(name, number, count, exception, format) \
1087    name = number,
1088#include "js.msg"
1089#undef MSG_DEF
1090    JSErr_Limit
1091} JSErrNum;
1092
1093extern JS_FRIEND_API(const JSErrorFormatString *)
1094js_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber);
1095
1096#ifdef va_start
1097extern JSBool
1098js_ReportErrorVA(JSContext *cx, uintN flags, const char *format, va_list ap);
1099
1100extern JSBool
1101js_ReportErrorNumberVA(JSContext *cx, uintN flags, JSErrorCallback callback,
1102                       void *userRef, const uintN errorNumber,
1103                       JSBool charArgs, va_list ap);
1104
1105extern JSBool
1106js_ExpandErrorArguments(JSContext *cx, JSErrorCallback callback,
1107                        void *userRef, const uintN errorNumber,
1108                        char **message, JSErrorReport *reportp,
1109                        JSBool *warningp, JSBool charArgs, va_list ap);
1110#endif
1111
1112extern void
1113js_ReportOutOfMemory(JSContext *cx);
1114
1115/*
1116 * Report that cx->scriptStackQuota is exhausted.
1117 */
1118extern void
1119js_ReportOutOfScriptQuota(JSContext *cx);
1120
1121extern void
1122js_ReportOverRecursed(JSContext *cx);
1123
1124extern void
1125js_ReportAllocationOverflow(JSContext *cx);
1126
1127#define JS_CHECK_RECURSION(cx, onerror)                                       \
1128    JS_BEGIN_MACRO                                                            \
1129        int stackDummy_;                                                      \
1130                                                                              \
1131        if (!JS_CHECK_STACK_SIZE(cx, stackDummy_)) {                          \
1132            js_ReportOverRecursed(cx);                                        \
1133            onerror;                                                          \
1134        }                                                                     \
1135    JS_END_MACRO
1136
1137/*
1138 * Report an exception using a previously composed JSErrorReport.
1139 * XXXbe remove from "friend" API
1140 */
1141extern JS_FRIEND_API(void)
1142js_ReportErrorAgain(JSContext *cx, const char *message, JSErrorReport *report);
1143
1144extern void
1145js_ReportIsNotDefined(JSContext *cx, const char *name);
1146
1147/*
1148 * Report an attempt to access the property of a null or undefined value (v).
1149 */
1150extern JSBool
1151js_ReportIsNullOrUndefined(JSContext *cx, intN spindex, jsval v,
1152                           JSString *fallback);
1153
1154extern void
1155js_ReportMissingArg(JSContext *cx, jsval *vp, uintN arg);
1156
1157/*
1158 * Report error using js_DecompileValueGenerator(cx, spindex, v, fallback) as
1159 * the first argument for the error message. If the error message has less
1160 * then 3 arguments, use null for arg1 or arg2.
1161 */
1162extern JSBool
1163js_ReportValueErrorFlags(JSContext *cx, uintN flags, const uintN errorNumber,
1164                         intN spindex, jsval v, JSString *fallback,
1165                         const char *arg1, const char *arg2);
1166
1167#define js_ReportValueError(cx,errorNumber,spindex,v,fallback)                \
1168    ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber,          \
1169                                    spindex, v, fallback, NULL, NULL))
1170
1171#define js_ReportValueError2(cx,errorNumber,spindex,v,fallback,arg1)          \
1172    ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber,          \
1173                                    spindex, v, fallback, arg1, NULL))
1174
1175#define js_ReportValueError3(cx,errorNumber,spindex,v,fallback,arg1,arg2)     \
1176    ((void)js_ReportValueErrorFlags(cx, JSREPORT_ERROR, errorNumber,          \
1177                                    spindex, v, fallback, arg1, arg2))
1178
1179extern JSErrorFormatString js_ErrorFormatString[JSErr_Limit];
1180
1181/*
1182 * See JS_SetThreadStackLimit in jsapi.c, where we check that the stack grows
1183 * in the expected direction.  On Unix-y systems, JS_STACK_GROWTH_DIRECTION is
1184 * computed on the build host by jscpucfg.c and written into jsautocfg.h.  The
1185 * macro is hardcoded in jscpucfg.h on Windows and Mac systems (for historical
1186 * reasons pre-dating autoconf usage).
1187 */
1188#if JS_STACK_GROWTH_DIRECTION > 0
1189# define JS_CHECK_STACK_SIZE(cx, lval)  ((jsuword)&(lval) < (cx)->stackLimit)
1190#else
1191# define JS_CHECK_STACK_SIZE(cx, lval)  ((jsuword)&(lval) > (cx)->stackLimit)
1192#endif
1193
1194/*
1195 * Update the operation counter according to the given weight and call the
1196 * operation callback when we reach the operation limit. To make this
1197 * frequently executed macro faster we decrease the counter from
1198 * JSContext.operationLimit and compare against zero to check the limit.
1199 *
1200 * This macro can run the full GC. Return true if it is OK to continue and
1201 * false otherwise.
1202 */
1203#define JS_CHECK_OPERATION_LIMIT(cx, weight)                                  \
1204    (JS_CHECK_OPERATION_WEIGHT(weight),                                       \
1205     (((cx)->operationCount -= (weight)) > 0 || js_ResetOperationCount(cx)))
1206
1207/*
1208 * A version of JS_CHECK_OPERATION_LIMIT that just updates the operation count
1209 * without calling the operation callback or any other API. This macro resets
1210 * the count to 0 when it becomes negative to prevent a wrap-around when the
1211 * macro is called repeatably.
1212 */
1213#define JS_COUNT_OPERATION(cx, weight)                                        \
1214    ((void)(JS_CHECK_OPERATION_WEIGHT(weight),                                \
1215            (cx)->operationCount = ((cx)->operationCount > 0)                 \
1216                                   ? (cx)->operationCount - (weight)          \
1217                                   : 0))
1218
1219/*
1220 * The implementation of the above macros assumes that subtracting weights
1221 * twice from a positive number does not wrap-around INT32_MIN.
1222 */
1223#define JS_CHECK_OPERATION_WEIGHT(weight)                                     \
1224    (JS_ASSERT((uint32) (weight) > 0),                                        \
1225     JS_ASSERT((uint32) (weight) < JS_BIT(30)))
1226
1227/* Relative operations weights. */
1228#define JSOW_JUMP                   1
1229#define JSOW_ALLOCATION             100
1230#define JSOW_LOOKUP_PROPERTY        5
1231#define JSOW_GET_PROPERTY           10
1232#define JSOW_SET_PROPERTY           20
1233#define JSOW_NEW_PROPERTY           200
1234#define JSOW_DELETE_PROPERTY        30
1235#define JSOW_ENTER_SHARP            JS_OPERATION_WEIGHT_BASE
1236#define JSOW_SCRIPT_JUMP            JS_OPERATION_WEIGHT_BASE
1237
1238/*
1239 * Reset the operation count and call the operation callback assuming that the
1240 * operation limit is reached.
1241 */
1242extern JSBool
1243js_ResetOperationCount(JSContext *cx);
1244
1245JS_END_EXTERN_C
1246
1247#endif /* jscntxt_h___ */