js/src/jsinterp.h

   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 jsinterp_h___
  42 #define jsinterp_h___
  43 /*
  44  * JS interpreter interface.
  45  */
  46 #include "jsprvtd.h"
  47 #include "jspubtd.h"
  48 #include "jsfun.h"
  49 #include "jsopcode.h"
  50 #include "jsscript.h"
  51
  52 JS_BEGIN_EXTERN_C
  53
  54 typedef struct JSFrameRegs {
  55     jsbytecode      *pc;            /* program counter */
  56     jsval           *sp;            /* stack pointer */
  57 } JSFrameRegs;
  58
  59 /*
  60  * JS stack frame, may be allocated on the C stack by native callers.  Always
  61  * allocated on cx->stackPool for calls from the interpreter to an interpreted
  62  * function.
  63  *
  64  * NB: This struct is manually initialized in jsinterp.c and jsiter.c.  If you
  65  * add new members, update both files.  But first, try to remove members.  The
  66  * sharp* and xml* members should be moved onto the stack as local variables
  67  * with well-known slots, if possible.
  68  */
  69 struct JSStackFrame {
  70     JSFrameRegs     *regs;
  71     jsbytecode      *imacpc;        /* null or interpreter macro call pc */
  72     jsval           *slots;         /* variables, locals and operand stack */
  73     JSObject        *callobj;       /* lazily created Call object */
  74     JSObject        *argsobj;       /* lazily created arguments object */
  75     JSObject        *varobj;        /* variables object, where vars go */
  76     JSObject        *callee;        /* function or script object */
  77     JSScript        *script;        /* script being interpreted */
  78     JSFunction      *fun;           /* function being called or null */
  79     JSObject        *thisp;         /* "this" pointer if in method */
  80     uintN           argc;           /* actual argument count */
  81     jsval           *argv;          /* base of argument stack slots */
  82     jsval           rval;           /* function return value */
  83     JSStackFrame    *down;          /* previous frame */
  84     void            *annotation;    /* used by Java security */
  85     JSObject        *scopeChain;    /* scope chain */
  86     uintN           sharpDepth;     /* array/object initializer depth */
  87     JSObject        *sharpArray;    /* scope for #n= initializer vars */
  88     uint32          flags;          /* frame flags -- see below */
  89     JSStackFrame    *dormantNext;   /* next dormant frame chain */
  90     JSObject        *xmlNamespace;  /* null or default xml namespace in E4X */
  91     JSObject        *blockChain;    /* active compile-time block scopes */
  92     JSStackFrame    *displaySave;   /* previous value of display entry for
  93                                        script->staticDepth */
  94 #ifdef DEBUG
  95     jsrefcount      pcDisabledSave; /* for balanced property cache control */
  96 #endif
  97 };
  98
  99 #ifdef __cplusplus
 100 static JS_INLINE uintN
 101 FramePCOffset(JSStackFrame* fp)
 102 {
 103     return uintN((fp->imacpc ? fp->imacpc : fp->regs->pc) - fp->script->code);
 104 }
 105 #endif
 106
 107 static JS_INLINE jsval *
 108 StackBase(JSStackFrame *fp)
 109 {
 110     return fp->slots + fp->script->nfixed;
 111 }
 112
 113 static JS_INLINE uintN
 114 GlobalVarCount(JSStackFrame *fp)
 115 {
 116     uintN n;
 117
 118     JS_ASSERT(!fp->fun);
 119     n = fp->script->nfixed;
 120     if (fp->script->regexpsOffset != 0)
 121         n -= JS_SCRIPT_REGEXPS(fp->script)->length;
 122     return n;
 123 }
 124
 125 typedef struct JSInlineFrame {
 126     JSStackFrame    frame;          /* base struct */
 127     JSFrameRegs     callerRegs;     /* parent's frame registers */
 128     void            *mark;          /* mark before inline frame */
 129     void            *hookData;      /* debugger call hook data */
 130     JSVersion       callerVersion;  /* dynamic version of calling script */
 131 } JSInlineFrame;
 132
 133 /* JS stack frame flags. */
 134 #define JSFRAME_CONSTRUCTING   0x01 /* frame is for a constructor invocation */
 135 #define JSFRAME_COMPUTED_THIS  0x02 /* frame.thisp was computed already */
 136 #define JSFRAME_ASSIGNING      0x04 /* a complex (not simplex JOF_ASSIGNING) op
 137                                        is currently assigning to a property */
 138 #define JSFRAME_DEBUGGER       0x08 /* frame for JS_EvaluateInStackFrame */
 139 #define JSFRAME_EVAL           0x10 /* frame for obj_eval */
 140 #define JSFRAME_ROOTED_ARGV    0x20 /* frame.argv is rooted by the caller */
 141 #define JSFRAME_YIELDING       0x40 /* js_Interpret dispatched JSOP_YIELD */
 142 #define JSFRAME_ITERATOR       0x80 /* trying to get an iterator for for-in */
 143 #define JSFRAME_POP_BLOCKS    0x100 /* scope chain contains blocks to pop */
 144 #define JSFRAME_GENERATOR     0x200 /* frame belongs to generator-iterator */
 145 #define JSFRAME_IMACRO_START  0x400 /* imacro starting -- see jstracer.h */
 146
 147 #define JSFRAME_OVERRIDE_SHIFT 24   /* override bit-set params; see jsfun.c */
 148 #define JSFRAME_OVERRIDE_BITS  8
 149
 150 #define JSFRAME_SPECIAL       (JSFRAME_DEBUGGER | JSFRAME_EVAL)
 151
 152 /*
 153  * Property cache with structurally typed capabilities for invalidation, for
 154  * polymorphic callsite method/get/set speedups.
 155  *
 156  * See bug https://bugzilla.mozilla.org/show_bug.cgi?id=365851.
 157  */
 158 #define PROPERTY_CACHE_LOG2     12
 159 #define PROPERTY_CACHE_SIZE     JS_BIT(PROPERTY_CACHE_LOG2)
 160 #define PROPERTY_CACHE_MASK     JS_BITMASK(PROPERTY_CACHE_LOG2)
 161
 162 /*
 163  * Add kshape rather than xor it to avoid collisions between nearby bytecode
 164  * that are evolving an object by setting successive properties, incrementing
 165  * the object's scope->shape on each set.
 166  */
 167 #define PROPERTY_CACHE_HASH(pc,kshape)                                        \
 168     (((((jsuword)(pc) >> PROPERTY_CACHE_LOG2) ^ (jsuword)(pc)) + (kshape)) &  \
 169      PROPERTY_CACHE_MASK)
 170
 171 #define PROPERTY_CACHE_HASH_PC(pc,kshape)                                     \
 172     PROPERTY_CACHE_HASH(pc, kshape)
 173
 174 #define PROPERTY_CACHE_HASH_ATOM(atom,obj,pobj)                               \
 175     PROPERTY_CACHE_HASH((jsuword)(atom) >> 2, OBJ_SHAPE(obj))
 176
 177 /*
 178  * Property cache value capability macros.
 179  */
 180 #define PCVCAP_PROTOBITS        4
 181 #define PCVCAP_PROTOSIZE        JS_BIT(PCVCAP_PROTOBITS)
 182 #define PCVCAP_PROTOMASK        JS_BITMASK(PCVCAP_PROTOBITS)
 183
 184 #define PCVCAP_SCOPEBITS        4
 185 #define PCVCAP_SCOPESIZE        JS_BIT(PCVCAP_SCOPEBITS)
 186 #define PCVCAP_SCOPEMASK        JS_BITMASK(PCVCAP_SCOPEBITS)
 187
 188 #define PCVCAP_TAGBITS          (PCVCAP_PROTOBITS + PCVCAP_SCOPEBITS)
 189 #define PCVCAP_TAGMASK          JS_BITMASK(PCVCAP_TAGBITS)
 190 #define PCVCAP_TAG(t)           ((t) & PCVCAP_TAGMASK)
 191
 192 #define PCVCAP_MAKE(t,s,p)      (((t) << PCVCAP_TAGBITS) |                    \
 193                                  ((s) << PCVCAP_PROTOBITS) |                  \
 194                                  (p))
 195 #define PCVCAP_SHAPE(t)         ((t) >> PCVCAP_TAGBITS)
 196
 197 #define SHAPE_OVERFLOW_BIT      JS_BIT(32 - PCVCAP_TAGBITS)
 198
 199 /*
 200  * When sprop is not null and the shape generation triggers the GC due to a
 201  * shape overflow, the functions roots sprop.
 202  */
 203 extern uint32
 204 js_GenerateShape(JSContext *cx, JSBool gcLocked, JSScopeProperty *sprop);
 205
 206 struct JSPropCacheEntry {
 207     jsbytecode          *kpc;           /* pc if vcap tag is <= 1, else atom */
 208     jsuword             kshape;         /* key shape if pc, else obj for atom */
 209     jsuword             vcap;           /* value capability, see above */
 210     jsuword             vword;          /* value word, see PCVAL_* below */
 211 };
 212
 213 #if defined DEBUG_brendan || defined DEBUG_brendaneich
 214 #define JS_PROPERTY_CACHE_METERING 1
 215 #endif
 216
 217 typedef struct JSPropertyCache {
 218     JSPropCacheEntry    table[PROPERTY_CACHE_SIZE];
 219     JSBool              empty;
 220     jsrefcount          disabled;       /* signed for anti-underflow asserts */
 221 #ifdef JS_PROPERTY_CACHE_METERING
 222     uint32              fills;          /* number of cache entry fills */
 223     uint32              nofills;        /* couldn't fill (e.g. default get) */
 224     uint32              rofills;        /* set on read-only prop can't fill */
 225     uint32              disfills;       /* fill attempts on disabled cache */
 226     uint32              oddfills;       /* fill attempt after setter deleted */
 227     uint32              modfills;       /* fill that rehashed to a new entry */
 228     uint32              brandfills;     /* scope brandings to type structural
 229                                            method fills */
 230     uint32              noprotos;       /* resolve-returned non-proto pobj */
 231     uint32              longchains;     /* overlong scope and/or proto chain */
 232     uint32              recycles;       /* cache entries recycled by fills */
 233     uint32              pcrecycles;     /* pc-keyed entries recycled by atom-
 234                                            keyed fills */
 235     uint32              tests;          /* cache probes */
 236     uint32              pchits;         /* fast-path polymorphic op hits */
 237     uint32              protopchits;    /* pchits hitting immediate prototype */
 238     uint32              initests;       /* cache probes from JSOP_INITPROP */
 239     uint32              inipchits;      /* init'ing next property pchit case */
 240     uint32              inipcmisses;    /* init'ing next property pc misses */
 241     uint32              settests;       /* cache probes from JOF_SET opcodes */
 242     uint32              addpchits;      /* adding next property pchit case */
 243     uint32              setpchits;      /* setting existing property pchit */
 244     uint32              setpcmisses;    /* setting/adding property pc misses */
 245     uint32              slotchanges;    /* clasp->reserveSlots result variance-
 246                                            induced slot changes */
 247     uint32              setmisses;      /* JSOP_SET{NAME,PROP} total misses */
 248     uint32              idmisses;       /* slow-path key id == atom misses */
 249     uint32              komisses;       /* slow-path key object misses */
 250     uint32              vcmisses;       /* value capability misses */
 251     uint32              misses;         /* cache misses */
 252     uint32              flushes;        /* cache flushes */
 253     uint32              pcpurges;       /* shadowing purges on proto chain */
 254 # define PCMETER(x)     x
 255 #else
 256 # define PCMETER(x)     ((void)0)
 257 #endif
 258 } JSPropertyCache;
 259
 260 /*
 261  * Property cache value tagging/untagging macros.
 262  */
 263 #define PCVAL_OBJECT            0
 264 #define PCVAL_SLOT              1
 265 #define PCVAL_SPROP             2
 266
 267 #define PCVAL_TAGBITS           2
 268 #define PCVAL_TAGMASK           JS_BITMASK(PCVAL_TAGBITS)
 269 #define PCVAL_TAG(v)            ((v) & PCVAL_TAGMASK)
 270 #define PCVAL_CLRTAG(v)         ((v) & ~(jsuword)PCVAL_TAGMASK)
 271 #define PCVAL_SETTAG(v,t)       ((jsuword)(v) | (t))
 272
 273 #define PCVAL_NULL              0
 274 #define PCVAL_IS_NULL(v)        ((v) == PCVAL_NULL)
 275
 276 #define PCVAL_IS_OBJECT(v)      (PCVAL_TAG(v) == PCVAL_OBJECT)
 277 #define PCVAL_TO_OBJECT(v)      ((JSObject *) (v))
 278 #define OBJECT_TO_PCVAL(obj)    ((jsuword) (obj))
 279
 280 #define PCVAL_OBJECT_TO_JSVAL(v) OBJECT_TO_JSVAL(PCVAL_TO_OBJECT(v))
 281 #define JSVAL_OBJECT_TO_PCVAL(v) OBJECT_TO_PCVAL(JSVAL_TO_OBJECT(v))
 282
 283 #define PCVAL_IS_SLOT(v)        ((v) & PCVAL_SLOT)
 284 #define PCVAL_TO_SLOT(v)        ((jsuint)(v) >> 1)
 285 #define SLOT_TO_PCVAL(i)        (((jsuword)(i) << 1) | PCVAL_SLOT)
 286
 287 #define PCVAL_IS_SPROP(v)       (PCVAL_TAG(v) == PCVAL_SPROP)
 288 #define PCVAL_TO_SPROP(v)       ((JSScopeProperty *) PCVAL_CLRTAG(v))
 289 #define SPROP_TO_PCVAL(sprop)   PCVAL_SETTAG(sprop, PCVAL_SPROP)
 290
 291 /*
 292  * Fill property cache entry for key cx->fp->pc, optimized value word computed
 293  * from obj and sprop, and entry capability forged from 24-bit OBJ_SHAPE(obj),
 294  * 4-bit scopeIndex, and 4-bit protoIndex.
 295  */
 296 extern JS_REQUIRES_STACK void
 297 js_FillPropertyCache(JSContext *cx, JSObject *obj, jsuword kshape,
 298                      uintN scopeIndex, uintN protoIndex,
 299                      JSObject *pobj, JSScopeProperty *sprop,
 300                      JSPropCacheEntry **entryp);
 301
 302 /*
 303  * Property cache lookup macros. PROPERTY_CACHE_TEST is designed to inline the
 304  * fast path in js_Interpret, so it makes "just-so" restrictions on parameters,
 305  * e.g. pobj and obj should not be the same variable, since for JOF_PROP-mode
 306  * opcodes, obj must not be changed because of a cache miss.
 307  *
 308  * On return from PROPERTY_CACHE_TEST, if atom is null then obj points to the
 309  * scope chain element in which the property was found, pobj is locked, and
 310  * entry is valid. If atom is non-null then no object is locked but entry is
 311  * still set correctly for use, e.g., by js_FillPropertyCache and atom should
 312  * be used as the id to find.
 313  *
 314  * We must lock pobj on a hit in order to close races with threads that might
 315  * be deleting a property from its scope, or otherwise invalidating property
 316  * caches (on all threads) by re-generating scope->shape.
 317  */
 318 #define PROPERTY_CACHE_TEST(cx, pc, obj, pobj, entry, atom)                   \
 319     do {                                                                      \
 320         JSPropertyCache *cache_ = &JS_PROPERTY_CACHE(cx);                     \
 321         uint32 kshape_ = (JS_ASSERT(OBJ_IS_NATIVE(obj)), OBJ_SHAPE(obj));     \
 322         entry = &cache_->table[PROPERTY_CACHE_HASH_PC(pc, kshape_)];          \
 323         PCMETER(cache_->tests++);                                             \
 324         JS_ASSERT(&obj != &pobj);                                             \
 325         if (entry->kpc == pc && entry->kshape == kshape_) {                   \
 326             JSObject *tmp_;                                                   \
 327             pobj = obj;                                                       \
 328             JS_LOCK_OBJ(cx, pobj);                                            \
 329             JS_ASSERT(PCVCAP_TAG(entry->vcap) <= 1);                          \
 330             if (PCVCAP_TAG(entry->vcap) == 1 &&                               \
 331                 (tmp_ = LOCKED_OBJ_GET_PROTO(pobj)) != NULL &&                \
 332                 OBJ_IS_NATIVE(tmp_)) {                                        \
 333                 JS_UNLOCK_OBJ(cx, pobj);                                      \
 334                 pobj = tmp_;                                                  \
 335                 JS_LOCK_OBJ(cx, pobj);                                        \
 336             }                                                                 \
 337             if (PCVCAP_SHAPE(entry->vcap) == OBJ_SHAPE(pobj)) {               \
 338                 PCMETER(cache_->pchits++);                                    \
 339                 PCMETER(!PCVCAP_TAG(entry->vcap) || cache_->protopchits++);   \
 340                 pobj = OBJ_SCOPE(pobj)->object;                               \
 341                 atom = NULL;                                                  \
 342                 break;                                                        \
 343             }                                                                 \
 344             JS_UNLOCK_OBJ(cx, pobj);                                          \
 345         }                                                                     \
 346         atom = js_FullTestPropertyCache(cx, pc, &obj, &pobj, &entry);         \
 347         if (atom)                                                             \
 348             PCMETER(cache_->misses++);                                        \
 349     } while (0)
 350
 351 extern JS_REQUIRES_STACK JSAtom *
 352 js_FullTestPropertyCache(JSContext *cx, jsbytecode *pc,
 353                          JSObject **objp, JSObject **pobjp,
 354                          JSPropCacheEntry **entryp);
 355
 356 extern void
 357 js_FlushPropertyCache(JSContext *cx);
 358
 359 extern void
 360 js_FlushPropertyCacheForScript(JSContext *cx, JSScript *script);
 361
 362 extern void
 363 js_DisablePropertyCache(JSContext *cx);
 364
 365 extern void
 366 js_EnablePropertyCache(JSContext *cx);
 367
 368 /*
 369  * Interpreter stack arena-pool alloc and free functions.
 370  */
 371 extern JS_FRIEND_API(jsval *)
 372 js_AllocStack(JSContext *cx, uintN nslots, void **markp);
 373
 374 extern JS_FRIEND_API(void)
 375 js_FreeStack(JSContext *cx, void *mark);
 376
 377 /*
 378  * Refresh and return fp->scopeChain.  It may be stale if block scopes are
 379  * active but not yet reflected by objects in the scope chain.  If a block
 380  * scope contains a with, eval, XML filtering predicate, or similar such
 381  * dynamically scoped construct, then compile-time block scope at fp->blocks
 382  * must reflect at runtime.
 383  */
 384 extern JSObject *
 385 js_GetScopeChain(JSContext *cx, JSStackFrame *fp);
 386
 387 /*
 388  * Given a context and a vector of [callee, this, args...] for a function that
 389  * was specified with a JSFUN_THISP_PRIMITIVE flag, get the primitive value of
 390  * |this| into *thisvp. In doing so, if |this| is an object, insist it is an
 391  * instance of clasp and extract its private slot value to return via *thisvp.
 392  *
 393  * NB: this function loads and uses *vp before storing *thisvp, so the two may
 394  * alias the same jsval.
 395  */
 396 extern JSBool
 397 js_GetPrimitiveThis(JSContext *cx, jsval *vp, JSClass *clasp, jsval *thisvp);
 398
 399 /*
 400  * For a call with arguments argv including argv[-1] (nominal |this|) and
 401  * argv[-2] (callee) replace null |this| with callee's parent, replace
 402  * primitive values with the equivalent wrapper objects and censor activation
 403  * objects as, per ECMA-262, they may not be referred to by |this|. argv[-1]
 404  * must not be a JSVAL_VOID.
 405  */
 406 extern JSObject *
 407 js_ComputeThis(JSContext *cx, JSBool lazy, jsval *argv);
 408
 409 extern const uint16 js_PrimitiveTestFlags[];
 410
 411 #define PRIMITIVE_THIS_TEST(fun,thisv)                                        \
 412     (JS_ASSERT(!JSVAL_IS_VOID(thisv)),                                        \
 413      JSFUN_THISP_TEST(JSFUN_THISP_FLAGS((fun)->flags),                        \
 414                       js_PrimitiveTestFlags[JSVAL_TAG(thisv) - 1]))
 415
 416 /*
 417  * NB: js_Invoke requires that cx is currently running JS (i.e., that cx->fp
 418  * is non-null), and that vp points to the callee, |this| parameter, and
 419  * actual arguments of the call. [vp .. vp + 2 + argc) must belong to the last
 420  * JS stack segment that js_AllocStack allocated. The function may use the
 421  * space available after vp + 2 + argc in the stack segment for temporaries,
 422  * so the caller should not use that space for values that must be preserved
 423  * across the call.
 424  */
 425 extern JS_FRIEND_API(JSBool)
 426 js_Invoke(JSContext *cx, uintN argc, jsval *vp, uintN flags);
 427
 428 /*
 429  * Consolidated js_Invoke flags simply rename certain JSFRAME_* flags, so that
 430  * we can share bits stored in JSStackFrame.flags and passed to:
 431  *
 432  *   js_Invoke
 433  *   js_InternalInvoke
 434  *   js_ValueToFunction
 435  *   js_ValueToFunctionObject
 436  *   js_ValueToCallableObject
 437  *   js_ReportIsNotFunction
 438  *
 439  * See jsfun.h for the latter four and flag renaming macros.
 440  */
 441 #define JSINVOKE_CONSTRUCT      JSFRAME_CONSTRUCTING
 442 #define JSINVOKE_ITERATOR       JSFRAME_ITERATOR
 443
 444 /*
 445  * Mask to isolate construct and iterator flags for use with jsfun.h functions.
 446  */
 447 #define JSINVOKE_FUNFLAGS       (JSINVOKE_CONSTRUCT | JSINVOKE_ITERATOR)
 448
 449 /*
 450  * "Internal" calls may come from C or C++ code using a JSContext on which no
 451  * JS is running (!cx->fp), so they may need to push a dummy JSStackFrame.
 452  */
 453 #define js_InternalCall(cx,obj,fval,argc,argv,rval)                           \
 454     js_InternalInvoke(cx, obj, fval, 0, argc, argv, rval)
 455
 456 #define js_InternalConstruct(cx,obj,fval,argc,argv,rval)                      \
 457     js_InternalInvoke(cx, obj, fval, JSINVOKE_CONSTRUCT, argc, argv, rval)
 458
 459 extern JSBool
 460 js_InternalInvoke(JSContext *cx, JSObject *obj, jsval fval, uintN flags,
 461                   uintN argc, jsval *argv, jsval *rval);
 462
 463 extern JSBool
 464 js_InternalGetOrSet(JSContext *cx, JSObject *obj, jsid id, jsval fval,
 465                     JSAccessMode mode, uintN argc, jsval *argv, jsval *rval);
 466
 467 extern JSBool
 468 js_Execute(JSContext *cx, JSObject *chain, JSScript *script,
 469            JSStackFrame *down, uintN flags, jsval *result);
 470
 471 extern JSBool
 472 js_InvokeConstructor(JSContext *cx, uintN argc, JSBool clampReturn, jsval *vp);
 473
 474 extern JS_REQUIRES_STACK JSBool
 475 js_Interpret(JSContext *cx);
 476
 477 #define JSPROP_INITIALIZER 0x100   /* NB: Not a valid property attribute. */
 478
 479 extern JSBool
 480 js_CheckRedeclaration(JSContext *cx, JSObject *obj, jsid id, uintN attrs,
 481                       JSObject **objp, JSProperty **propp);
 482
 483 extern JSBool
 484 js_StrictlyEqual(JSContext *cx, jsval lval, jsval rval);
 485
 486 /*
 487  * JS_LONE_INTERPRET indicates that the compiler should see just the code for
 488  * the js_Interpret function when compiling jsinterp.cpp. The rest of the code
 489  * from the file should be visible only when compiling jsinvoke.cpp. It allows
 490  * platform builds to optimize selectively js_Interpret when the granularity
 491  * of the optimizations with the given compiler is a compilation unit.
 492  *
 493  * JS_STATIC_INTERPRET is the modifier for functions defined in jsinterp.cpp
 494  * that only js_Interpret calls. When JS_LONE_INTERPRET is true all such
 495  * functions are declared below.
 496  */
 497 #ifndef JS_LONE_INTERPRET
 498 # ifdef _MSC_VER
 499 #  define JS_LONE_INTERPRET 0
 500 # else
 501 #  define JS_LONE_INTERPRET 1
 502 # endif
 503 #endif
 504
 505 #if !JS_LONE_INTERPRET
 506 # define JS_STATIC_INTERPRET    static
 507 #else
 508 # define JS_STATIC_INTERPRET
 509
 510 extern jsval *
 511 js_AllocRawStack(JSContext *cx, uintN nslots, void **markp);
 512
 513 extern void
 514 js_FreeRawStack(JSContext *cx, void *mark);
 515
 516 /*
 517  * ECMA requires "the global object", but in embeddings such as the browser,
 518  * which have multiple top-level objects (windows, frames, etc. in the DOM),
 519  * we prefer fun's parent.  An example that causes this code to run:
 520  *
 521  *   // in window w1
 522  *   function f() { return this }
 523  *   function g() { return f }
 524  *
 525  *   // in window w2
 526  *   var h = w1.g()
 527  *   alert(h() == w1)
 528  *
 529  * The alert should display "true".
 530  */
 531 extern JSObject *
 532 js_ComputeGlobalThis(JSContext *cx, JSBool lazy, jsval *argv);
 533
 534 extern JS_REQUIRES_STACK JSBool
 535 js_EnterWith(JSContext *cx, jsint stackIndex);
 536
 537 extern JS_REQUIRES_STACK void
 538 js_LeaveWith(JSContext *cx);
 539
 540 extern JS_REQUIRES_STACK JSClass *
 541 js_IsActiveWithOrBlock(JSContext *cx, JSObject *obj, int stackDepth);
 542
 543 extern jsint
 544 js_CountWithBlocks(JSContext *cx, JSStackFrame *fp);
 545
 546 /*
 547  * Unwind block and scope chains to match the given depth. The function sets
 548  * fp->sp on return to stackDepth.
 549  */
 550 extern JS_REQUIRES_STACK JSBool
 551 js_UnwindScope(JSContext *cx, JSStackFrame *fp, jsint stackDepth,
 552                JSBool normalUnwind);
 553
 554 extern JSBool
 555 js_InternNonIntElementId(JSContext *cx, JSObject *obj, jsval idval, jsid *idp);
 556
 557 extern JSBool
 558 js_OnUnknownMethod(JSContext *cx, jsval *vp);
 559
 560 /*
 561  * Find the results of incrementing or decrementing *vp. For pre-increments,
 562  * both *vp and *vp2 will contain the result on return. For post-increments,
 563  * vp will contain the original value converted to a number and vp2 will get
 564  * the result. Both vp and vp2 must be roots.
 565  */
 566 extern JSBool
 567 js_DoIncDec(JSContext *cx, const JSCodeSpec *cs, jsval *vp, jsval *vp2);
 568
 569 /*
 570  * Opcode tracing helper. When len is not 0, cx->fp->regs->pc[-len] gives the
 571  * previous opcode.
 572  */
 573 extern JS_REQUIRES_STACK void
 574 js_TraceOpcode(JSContext *cx, jsint len);
 575
 576 /*
 577  * JS_OPMETER helper functions.
 578  */
 579 extern void
 580 js_MeterOpcodePair(JSOp op1, JSOp op2);
 581
 582 extern void
 583 js_MeterSlotOpcode(JSOp op, uint32 slot);
 584
 585 #endif /* JS_LONE_INTERPRET */
 586
 587 JS_END_EXTERN_C
 588
 589 #endif /* jsinterp_h___ */