mirror of https://github.com/axmolengine/axmol.git
364 lines
9.9 KiB
C++
364 lines
9.9 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef jsprvtd_h___
|
|
#define jsprvtd_h___
|
|
/*
|
|
* JS private typename definitions.
|
|
*
|
|
* This header is included only in other .h files, for convenience and for
|
|
* simplicity of type naming. The alternative for structures is to use tags,
|
|
* which are named the same as their typedef names (legal in C/C++, and less
|
|
* noisy than suffixing the typedef name with "Struct" or "Str"). Instead,
|
|
* all .h files that include this file may use the same typedef name, whether
|
|
* declaring a pointer to struct type, or defining a member of struct type.
|
|
*
|
|
* A few fundamental scalar types are defined here too. Neither the scalar
|
|
* nor the struct typedefs should change much, therefore the nearly-global
|
|
* make dependency induced by this file should not prove painful.
|
|
*/
|
|
|
|
#include "jsapi.h"
|
|
#include "jsutil.h"
|
|
|
|
#ifdef __cplusplus
|
|
#include "js/HashTable.h"
|
|
#include "js/Vector.h"
|
|
#endif
|
|
|
|
/*
|
|
* Convenience constants.
|
|
*/
|
|
#define JS_BITS_PER_UINT32_LOG2 5
|
|
#define JS_BITS_PER_UINT32 32
|
|
|
|
/* The alignment required of objects stored in GC arenas. */
|
|
static const unsigned JS_GCTHING_ALIGN = 8;
|
|
static const unsigned JS_GCTHING_ZEROBITS = 3;
|
|
|
|
/* Scalar typedefs. */
|
|
typedef uint8_t jsbytecode;
|
|
typedef uint8_t jssrcnote;
|
|
typedef uintptr_t jsatomid;
|
|
|
|
/* Struct typedefs. */
|
|
typedef struct JSGCThing JSGCThing;
|
|
typedef struct JSGenerator JSGenerator;
|
|
typedef struct JSNativeEnumerator JSNativeEnumerator;
|
|
typedef struct JSTryNote JSTryNote;
|
|
|
|
/* Friend "Advanced API" typedefs. */
|
|
typedef struct JSAtomState JSAtomState;
|
|
typedef struct JSCodeSpec JSCodeSpec;
|
|
typedef struct JSPrinter JSPrinter;
|
|
typedef struct JSStackHeader JSStackHeader;
|
|
typedef struct JSSubString JSSubString;
|
|
typedef struct JSSpecializedNative JSSpecializedNative;
|
|
|
|
#if JS_HAS_XML_SUPPORT
|
|
typedef struct JSXML JSXML;
|
|
#endif
|
|
|
|
/*
|
|
* Template declarations.
|
|
*
|
|
* jsprvtd.h can be included in both C and C++ translation units. For C++, it
|
|
* may possibly be wrapped in an extern "C" block which does not agree with
|
|
* templates.
|
|
*/
|
|
#ifdef __cplusplus
|
|
|
|
extern "C++" {
|
|
|
|
class JSDependentString;
|
|
class JSExtensibleString;
|
|
class JSExternalString;
|
|
class JSLinearString;
|
|
class JSRope;
|
|
class JSAtom;
|
|
class JSWrapper;
|
|
|
|
namespace js {
|
|
|
|
struct ArgumentsData;
|
|
struct Class;
|
|
|
|
class RegExpGuard;
|
|
class RegExpObject;
|
|
class RegExpObjectBuilder;
|
|
class RegExpShared;
|
|
class RegExpStatics;
|
|
class MatchPairs;
|
|
class PropertyName;
|
|
|
|
enum RegExpFlag
|
|
{
|
|
IgnoreCaseFlag = 0x01,
|
|
GlobalFlag = 0x02,
|
|
MultilineFlag = 0x04,
|
|
StickyFlag = 0x08,
|
|
|
|
NoFlags = 0x00,
|
|
AllFlags = 0x0f
|
|
};
|
|
|
|
class ExecuteArgsGuard;
|
|
class InvokeFrameGuard;
|
|
class InvokeArgsGuard;
|
|
class StringBuffer;
|
|
|
|
class FrameRegs;
|
|
class StackFrame;
|
|
class StackSegment;
|
|
class StackSpace;
|
|
class ContextStack;
|
|
class ScriptFrameIter;
|
|
|
|
class Proxy;
|
|
class JS_FRIEND_API(BaseProxyHandler);
|
|
class JS_FRIEND_API(Wrapper);
|
|
class JS_FRIEND_API(CrossCompartmentWrapper);
|
|
|
|
class TempAllocPolicy;
|
|
class RuntimeAllocPolicy;
|
|
|
|
class GlobalObject;
|
|
|
|
template <typename K,
|
|
typename V,
|
|
size_t InlineElems>
|
|
class InlineMap;
|
|
|
|
class LifoAlloc;
|
|
|
|
class Shape;
|
|
|
|
class Breakpoint;
|
|
class BreakpointSite;
|
|
class Debugger;
|
|
class WatchpointMap;
|
|
|
|
/*
|
|
* Env is the type of what ES5 calls "lexical environments" (runtime
|
|
* activations of lexical scopes). This is currently just JSObject, and is
|
|
* implemented by Call, Block, With, and DeclEnv objects, among others--but
|
|
* environments and objects are really two different concepts.
|
|
*/
|
|
typedef JSObject Env;
|
|
|
|
typedef JSNative Native;
|
|
typedef JSPropertyOp PropertyOp;
|
|
typedef JSStrictPropertyOp StrictPropertyOp;
|
|
typedef JSPropertyDescriptor PropertyDescriptor;
|
|
|
|
namespace frontend {
|
|
|
|
struct BytecodeEmitter;
|
|
struct Definition;
|
|
class FunctionBox;
|
|
class ObjectBox;
|
|
struct Token;
|
|
struct TokenPos;
|
|
struct TokenPtr;
|
|
class TokenStream;
|
|
struct Parser;
|
|
class ParseMapPool;
|
|
struct ParseNode;
|
|
|
|
} /* namespace frontend */
|
|
|
|
namespace analyze {
|
|
|
|
struct LifetimeVariable;
|
|
class LoopAnalysis;
|
|
class ScriptAnalysis;
|
|
class SlotValue;
|
|
class SSAValue;
|
|
class SSAUseChain;
|
|
|
|
} /* namespace analyze */
|
|
|
|
namespace types {
|
|
|
|
class TypeSet;
|
|
struct TypeCallsite;
|
|
struct TypeObject;
|
|
struct TypeCompartment;
|
|
|
|
} /* namespace types */
|
|
|
|
typedef JS::Handle<Shape*> HandleShape;
|
|
typedef JS::Handle<types::TypeObject*> HandleTypeObject;
|
|
typedef JS::Handle<JSAtom*> HandleAtom;
|
|
typedef JS::Handle<PropertyName*> HandlePropertyName;
|
|
|
|
typedef JS::MutableHandle<Shape*> MutableHandleShape;
|
|
typedef JS::MutableHandle<JSAtom*> MutableHandleAtom;
|
|
|
|
typedef JSAtom * RawAtom;
|
|
|
|
typedef js::Rooted<Shape*> RootedShape;
|
|
typedef js::Rooted<types::TypeObject*> RootedTypeObject;
|
|
typedef js::Rooted<JSAtom*> RootedAtom;
|
|
typedef js::Rooted<PropertyName*> RootedPropertyName;
|
|
|
|
enum XDRMode {
|
|
XDR_ENCODE,
|
|
XDR_DECODE
|
|
};
|
|
|
|
template <XDRMode mode>
|
|
class XDRState;
|
|
|
|
class FreeOp;
|
|
|
|
} /* namespace js */
|
|
|
|
namespace JSC {
|
|
|
|
class ExecutableAllocator;
|
|
|
|
} /* namespace JSC */
|
|
|
|
namespace WTF {
|
|
|
|
class BumpPointerAllocator;
|
|
|
|
} /* namespace WTF */
|
|
|
|
} /* export "C++" */
|
|
|
|
#else
|
|
|
|
typedef struct JSAtom JSAtom;
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
/* "Friend" types used by jscntxt.h and jsdbgapi.h. */
|
|
typedef enum JSTrapStatus {
|
|
JSTRAP_ERROR,
|
|
JSTRAP_CONTINUE,
|
|
JSTRAP_RETURN,
|
|
JSTRAP_THROW,
|
|
JSTRAP_LIMIT
|
|
} JSTrapStatus;
|
|
|
|
typedef JSTrapStatus
|
|
(* JSTrapHandler)(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
|
|
jsval closure);
|
|
|
|
typedef JSTrapStatus
|
|
(* JSInterruptHook)(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
|
|
void *closure);
|
|
|
|
typedef JSTrapStatus
|
|
(* JSDebuggerHandler)(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
|
|
void *closure);
|
|
|
|
typedef JSTrapStatus
|
|
(* JSThrowHook)(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
|
|
void *closure);
|
|
|
|
typedef JSBool
|
|
(* JSWatchPointHandler)(JSContext *cx, JSObject *obj, jsid id, jsval old,
|
|
jsval *newp, void *closure);
|
|
|
|
/* called just after script creation */
|
|
typedef void
|
|
(* JSNewScriptHook)(JSContext *cx,
|
|
const char *filename, /* URL of script */
|
|
unsigned lineno, /* first line */
|
|
JSScript *script,
|
|
JSFunction *fun,
|
|
void *callerdata);
|
|
|
|
/* called just before script destruction */
|
|
typedef void
|
|
(* JSDestroyScriptHook)(JSFreeOp *fop,
|
|
JSScript *script,
|
|
void *callerdata);
|
|
|
|
typedef void
|
|
(* JSSourceHandler)(const char *filename, unsigned lineno, const jschar *str,
|
|
size_t length, void **listenerTSData, void *closure);
|
|
|
|
/*
|
|
* This hook captures high level script execution and function calls (JS or
|
|
* native). It is used by JS_SetExecuteHook to hook top level scripts and by
|
|
* JS_SetCallHook to hook function calls. It will get called twice per script
|
|
* or function call: just before execution begins and just after it finishes.
|
|
* In both cases the 'current' frame is that of the executing code.
|
|
*
|
|
* The 'before' param is JS_TRUE for the hook invocation before the execution
|
|
* and JS_FALSE for the invocation after the code has run.
|
|
*
|
|
* The 'ok' param is significant only on the post execution invocation to
|
|
* signify whether or not the code completed 'normally'.
|
|
*
|
|
* The 'closure' param is as passed to JS_SetExecuteHook or JS_SetCallHook
|
|
* for the 'before'invocation, but is whatever value is returned from that
|
|
* invocation for the 'after' invocation. Thus, the hook implementor *could*
|
|
* allocate a structure in the 'before' invocation and return a pointer to that
|
|
* structure. The pointer would then be handed to the hook for the 'after'
|
|
* invocation. Alternately, the 'before' could just return the same value as
|
|
* in 'closure' to cause the 'after' invocation to be called with the same
|
|
* 'closure' value as the 'before'.
|
|
*
|
|
* Returning NULL in the 'before' hook will cause the 'after' hook *not* to
|
|
* be called.
|
|
*/
|
|
typedef void *
|
|
(* JSInterpreterHook)(JSContext *cx, JSStackFrame *fp, JSBool before,
|
|
JSBool *ok, void *closure);
|
|
|
|
typedef JSBool
|
|
(* JSDebugErrorHook)(JSContext *cx, const char *message, JSErrorReport *report,
|
|
void *closure);
|
|
|
|
typedef struct JSDebugHooks {
|
|
JSInterruptHook interruptHook;
|
|
void *interruptHookData;
|
|
JSNewScriptHook newScriptHook;
|
|
void *newScriptHookData;
|
|
JSDestroyScriptHook destroyScriptHook;
|
|
void *destroyScriptHookData;
|
|
JSDebuggerHandler debuggerHandler;
|
|
void *debuggerHandlerData;
|
|
JSSourceHandler sourceHandler;
|
|
void *sourceHandlerData;
|
|
JSInterpreterHook executeHook;
|
|
void *executeHookData;
|
|
JSInterpreterHook callHook;
|
|
void *callHookData;
|
|
JSThrowHook throwHook;
|
|
void *throwHookData;
|
|
JSDebugErrorHook debugErrorHook;
|
|
void *debugErrorHookData;
|
|
} JSDebugHooks;
|
|
|
|
/* js::ObjectOps function pointer typedefs. */
|
|
|
|
/*
|
|
* A generic type for functions mapping an object to another object, or null
|
|
* if an error or exception was thrown on cx.
|
|
*/
|
|
typedef JSObject *
|
|
(* JSObjectOp)(JSContext *cx, JSHandleObject obj);
|
|
|
|
/* Signature for class initialization ops. */
|
|
typedef JSObject *
|
|
(* JSClassInitializerOp)(JSContext *cx, JSHandleObject obj);
|
|
|
|
/*
|
|
* Hook that creates an iterator object for a given object. Returns the
|
|
* iterator object or null if an error or exception was thrown on cx.
|
|
*/
|
|
typedef JSObject *
|
|
(* JSIteratorOp)(JSContext *cx, JSHandleObject obj, JSBool keysonly);
|
|
|
|
|
|
#endif /* jsprvtd_h___ */
|