mirror of https://github.com/axmolengine/axmol.git
433 lines
14 KiB
C++
433 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sw=4 et tw=99:
|
|
*
|
|
* 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 jsdbgapi_h___
|
|
#define jsdbgapi_h___
|
|
/*
|
|
* JS debugger API.
|
|
*/
|
|
#include "jsapi.h"
|
|
#include "jsprvtd.h"
|
|
|
|
namespace JS {
|
|
|
|
struct FrameDescription
|
|
{
|
|
JSScript *script;
|
|
unsigned lineno;
|
|
JSFunction *fun;
|
|
};
|
|
|
|
struct StackDescription
|
|
{
|
|
unsigned nframes;
|
|
FrameDescription *frames;
|
|
};
|
|
|
|
extern JS_PUBLIC_API(StackDescription *)
|
|
DescribeStack(JSContext *cx, unsigned maxFrames);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
FreeStackDescription(JSContext *cx, StackDescription *desc);
|
|
|
|
extern JS_PUBLIC_API(char *)
|
|
FormatStackDump(JSContext *cx, char *buf,
|
|
JSBool showArgs, JSBool showLocals,
|
|
JSBool showThisProps);
|
|
|
|
}
|
|
|
|
# ifdef DEBUG
|
|
JS_FRIEND_API(void) js_DumpValue(const js::Value &val);
|
|
JS_FRIEND_API(void) js_DumpId(jsid id);
|
|
JS_FRIEND_API(void) js_DumpStackFrame(JSContext *cx, js::StackFrame *start = NULL);
|
|
# endif
|
|
|
|
JS_FRIEND_API(void)
|
|
js_DumpBacktrace(JSContext *cx);
|
|
|
|
extern JS_PUBLIC_API(JSCompartment *)
|
|
JS_EnterCompartmentOfScript(JSContext *cx, JSScript *target);
|
|
|
|
extern JS_PUBLIC_API(JSString *)
|
|
JS_DecompileScript(JSContext *cx, JSScript *script, const char *name, unsigned indent);
|
|
|
|
/*
|
|
* Currently, we only support runtime-wide debugging. In the future, we should
|
|
* be able to support compartment-wide debugging.
|
|
*/
|
|
extern JS_PUBLIC_API(void)
|
|
JS_SetRuntimeDebugMode(JSRuntime *rt, JSBool debug);
|
|
|
|
/*
|
|
* Debug mode is a compartment-wide mode that enables a debugger to attach
|
|
* to and interact with running methodjit-ed frames. In particular, it causes
|
|
* every function to be compiled as if an eval was present (so eval-in-frame)
|
|
* can work, and it ensures that functions can be re-JITed for other debug
|
|
* features. In general, it is not safe to interact with frames that were live
|
|
* before debug mode was enabled. For this reason, it is also not safe to
|
|
* enable debug mode while frames are live.
|
|
*/
|
|
|
|
/* Get current state of debugging mode. */
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_GetDebugMode(JSContext *cx);
|
|
|
|
/*
|
|
* Turn on/off debugging mode for all compartments. This returns false if any code
|
|
* from any of the runtime's compartments is running or on the stack.
|
|
*/
|
|
JS_FRIEND_API(JSBool)
|
|
JS_SetDebugModeForAllCompartments(JSContext *cx, JSBool debug);
|
|
|
|
/*
|
|
* Turn on/off debugging mode for a single compartment. This should only be
|
|
* used when no code from this compartment is running or on the stack in any
|
|
* thread.
|
|
*/
|
|
JS_FRIEND_API(JSBool)
|
|
JS_SetDebugModeForCompartment(JSContext *cx, JSCompartment *comp, JSBool debug);
|
|
|
|
/*
|
|
* Turn on/off debugging mode for a context's compartment.
|
|
*/
|
|
JS_FRIEND_API(JSBool)
|
|
JS_SetDebugMode(JSContext *cx, JSBool debug);
|
|
|
|
/* Turn on single step mode. */
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetSingleStepMode(JSContext *cx, JSScript *script, JSBool singleStep);
|
|
|
|
/* The closure argument will be marked. */
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetTrap(JSContext *cx, JSScript *script, jsbytecode *pc,
|
|
JSTrapHandler handler, jsval closure);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_ClearTrap(JSContext *cx, JSScript *script, jsbytecode *pc,
|
|
JSTrapHandler *handlerp, jsval *closurep);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_ClearScriptTraps(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_ClearAllTrapsForCompartment(JSContext *cx);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetInterrupt(JSRuntime *rt, JSInterruptHook handler, void *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_ClearInterrupt(JSRuntime *rt, JSInterruptHook *handlerp, void **closurep);
|
|
|
|
/************************************************************************/
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetWatchPoint(JSContext *cx, JSObject *obj, jsid id,
|
|
JSWatchPointHandler handler, JSObject *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_ClearWatchPoint(JSContext *cx, JSObject *obj, jsid id,
|
|
JSWatchPointHandler *handlerp, JSObject **closurep);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_ClearWatchPointsForObject(JSContext *cx, JSObject *obj);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_ClearAllWatchPoints(JSContext *cx);
|
|
|
|
/************************************************************************/
|
|
|
|
// RawScript because this needs to be callable from a signal handler
|
|
extern JS_PUBLIC_API(unsigned)
|
|
JS_PCToLineNumber(JSContext *cx, js::RawScript script, jsbytecode *pc);
|
|
|
|
extern JS_PUBLIC_API(jsbytecode *)
|
|
JS_LineNumberToPC(JSContext *cx, JSScript *script, unsigned lineno);
|
|
|
|
extern JS_PUBLIC_API(jsbytecode *)
|
|
JS_EndPC(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_GetLinePCs(JSContext *cx, JSScript *script,
|
|
unsigned startLine, unsigned maxLines,
|
|
unsigned* count, unsigned** lines, jsbytecode*** pcs);
|
|
|
|
extern JS_PUBLIC_API(unsigned)
|
|
JS_GetFunctionArgumentCount(JSContext *cx, JSFunction *fun);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_FunctionHasLocalNames(JSContext *cx, JSFunction *fun);
|
|
|
|
/*
|
|
* N.B. The mark is in the context temp pool and thus the caller must take care
|
|
* to call JS_ReleaseFunctionLocalNameArray in a LIFO manner (wrt to any other
|
|
* call that may use the temp pool.
|
|
*/
|
|
extern JS_PUBLIC_API(uintptr_t *)
|
|
JS_GetFunctionLocalNameArray(JSContext *cx, JSFunction *fun, void **markp);
|
|
|
|
extern JS_PUBLIC_API(JSAtom *)
|
|
JS_LocalNameToAtom(uintptr_t w);
|
|
|
|
extern JS_PUBLIC_API(JSString *)
|
|
JS_AtomKey(JSAtom *atom);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_ReleaseFunctionLocalNameArray(JSContext *cx, void *mark);
|
|
|
|
extern JS_PUBLIC_API(JSScript *)
|
|
JS_GetFunctionScript(JSContext *cx, JSFunction *fun);
|
|
|
|
extern JS_PUBLIC_API(JSNative)
|
|
JS_GetFunctionNative(JSContext *cx, JSFunction *fun);
|
|
|
|
extern JS_PUBLIC_API(JSPrincipals *)
|
|
JS_GetScriptPrincipals(JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(JSPrincipals *)
|
|
JS_GetScriptOriginPrincipals(JSScript *script);
|
|
|
|
/*
|
|
* This function does not work when IonMonkey is active. It remains for legacy
|
|
* code: caps/principal clamping, which will be removed shortly after
|
|
* compartment-per-global, and jsd, which can only be used when IonMonkey is
|
|
* disabled.
|
|
*
|
|
* To find the calling script and line number, use JS_DescribeSciptedCaller.
|
|
* To summarize the call stack, use JS::DescribeStack.
|
|
*/
|
|
extern JS_PUBLIC_API(JSStackFrame *)
|
|
JS_BrokenFrameIterator(JSContext *cx, JSStackFrame **iteratorp);
|
|
|
|
extern JS_PUBLIC_API(JSScript *)
|
|
JS_GetFrameScript(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(jsbytecode *)
|
|
JS_GetFramePC(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(void *)
|
|
JS_GetFrameAnnotation(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_SetTopFrameAnnotation(JSContext *cx, void *annotation);
|
|
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_GetFrameScopeChain(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_GetFrameCallObject(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_GetFrameThis(JSContext *cx, JSStackFrame *fp, jsval *thisv);
|
|
|
|
extern JS_PUBLIC_API(JSFunction *)
|
|
JS_GetFrameFunction(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_GetFrameFunctionObject(JSContext *cx, JSStackFrame *fp);
|
|
|
|
JS_PUBLIC_API(JSFunction *)
|
|
JS_GetScriptFunction(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_GetParentOrScopeChain(JSContext *cx, JSObject *obj);
|
|
|
|
/* XXXrginda Initially published with typo */
|
|
#define JS_IsContructorFrame JS_IsConstructorFrame
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_IsConstructorFrame(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_IsDebuggerFrame(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_IsGlobalFrame(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(jsval)
|
|
JS_GetFrameReturnValue(JSContext *cx, JSStackFrame *fp);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_SetFrameReturnValue(JSContext *cx, JSStackFrame *fp, jsval rval);
|
|
|
|
/**
|
|
* Return fp's callee function object (fp->callee) if it has one. Note that
|
|
* this API cannot fail. A null return means "no callee": fp is a global or
|
|
* eval-from-global frame, not a call frame.
|
|
*/
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_GetFrameCalleeObject(JSContext *cx, JSStackFrame *fp);
|
|
|
|
/************************************************************************/
|
|
|
|
/*
|
|
* This is almost JS_GetClass(obj)->name except that certain debug-only
|
|
* proxies are made transparent. In particular, this function turns the class
|
|
* of any scope (returned via JS_GetFrameScopeChain or JS_GetFrameCalleeObject)
|
|
* from "Proxy" to "Call", "Block", "With" etc.
|
|
*/
|
|
extern JS_PUBLIC_API(const char *)
|
|
JS_GetDebugClassName(JSObject *obj);
|
|
|
|
/************************************************************************/
|
|
|
|
extern JS_PUBLIC_API(const char *)
|
|
JS_GetScriptFilename(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(const jschar *)
|
|
JS_GetScriptSourceMap(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(unsigned)
|
|
JS_GetScriptBaseLineNumber(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(unsigned)
|
|
JS_GetScriptLineExtent(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(JSVersion)
|
|
JS_GetScriptVersion(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(bool)
|
|
JS_GetScriptUserBit(JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_SetScriptUserBit(JSScript *script, bool b);
|
|
|
|
/************************************************************************/
|
|
|
|
/*
|
|
* Hook setters for script creation and destruction, see jsprvtd.h for the
|
|
* typedefs. These macros provide binary compatibility and newer, shorter
|
|
* synonyms.
|
|
*/
|
|
#define JS_SetNewScriptHook JS_SetNewScriptHookProc
|
|
#define JS_SetDestroyScriptHook JS_SetDestroyScriptHookProc
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_SetNewScriptHook(JSRuntime *rt, JSNewScriptHook hook, void *callerdata);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_SetDestroyScriptHook(JSRuntime *rt, JSDestroyScriptHook hook,
|
|
void *callerdata);
|
|
|
|
/************************************************************************/
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_EvaluateUCInStackFrame(JSContext *cx, JSStackFrame *fp,
|
|
const jschar *chars, unsigned length,
|
|
const char *filename, unsigned lineno,
|
|
jsval *rval);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_EvaluateInStackFrame(JSContext *cx, JSStackFrame *fp,
|
|
const char *bytes, unsigned length,
|
|
const char *filename, unsigned lineno,
|
|
jsval *rval);
|
|
|
|
/************************************************************************/
|
|
|
|
typedef struct JSPropertyDesc {
|
|
jsval id; /* primary id, atomized string, or int */
|
|
jsval value; /* property value */
|
|
uint8_t flags; /* flags, see below */
|
|
uint8_t spare; /* unused */
|
|
jsval alias; /* alias id if JSPD_ALIAS flag */
|
|
} JSPropertyDesc;
|
|
|
|
#define JSPD_ENUMERATE 0x01 /* visible to for/in loop */
|
|
#define JSPD_READONLY 0x02 /* assignment is error */
|
|
#define JSPD_PERMANENT 0x04 /* property cannot be deleted */
|
|
#define JSPD_ALIAS 0x08 /* property has an alias id */
|
|
#define JSPD_EXCEPTION 0x40 /* exception occurred fetching the property, */
|
|
/* value is exception */
|
|
#define JSPD_ERROR 0x80 /* native getter returned JS_FALSE without */
|
|
/* throwing an exception */
|
|
|
|
typedef struct JSPropertyDescArray {
|
|
uint32_t length; /* number of elements in array */
|
|
JSPropertyDesc *array; /* alloc'd by Get, freed by Put */
|
|
} JSPropertyDescArray;
|
|
|
|
typedef struct JSScopeProperty JSScopeProperty;
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_GetPropertyDescArray(JSContext *cx, JSObject *obj, JSPropertyDescArray *pda);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_PutPropertyDescArray(JSContext *cx, JSPropertyDescArray *pda);
|
|
|
|
/************************************************************************/
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetDebuggerHandler(JSRuntime *rt, JSDebuggerHandler hook, void *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetSourceHandler(JSRuntime *rt, JSSourceHandler handler, void *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetExecuteHook(JSRuntime *rt, JSInterpreterHook hook, void *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetCallHook(JSRuntime *rt, JSInterpreterHook hook, void *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetThrowHook(JSRuntime *rt, JSThrowHook hook, void *closure);
|
|
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_SetDebugErrorHook(JSRuntime *rt, JSDebugErrorHook hook, void *closure);
|
|
|
|
/************************************************************************/
|
|
|
|
extern JS_PUBLIC_API(size_t)
|
|
JS_GetObjectTotalSize(JSContext *cx, JSObject *obj);
|
|
|
|
extern JS_PUBLIC_API(size_t)
|
|
JS_GetFunctionTotalSize(JSContext *cx, JSFunction *fun);
|
|
|
|
extern JS_PUBLIC_API(size_t)
|
|
JS_GetScriptTotalSize(JSContext *cx, JSScript *script);
|
|
|
|
/************************************************************************/
|
|
|
|
extern JS_FRIEND_API(void)
|
|
js_RevertVersion(JSContext *cx);
|
|
|
|
extern JS_PUBLIC_API(const JSDebugHooks *)
|
|
JS_GetGlobalDebugHooks(JSRuntime *rt);
|
|
|
|
/**
|
|
* Add various profiling-related functions as properties of the given object.
|
|
*/
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_DefineProfilingFunctions(JSContext *cx, JSObject *obj);
|
|
|
|
/* Defined in vm/Debugger.cpp. */
|
|
extern JS_PUBLIC_API(JSBool)
|
|
JS_DefineDebuggerObject(JSContext *cx, JSObject *obj);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_DumpBytecode(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_DumpCompartmentBytecode(JSContext *cx);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_DumpPCCounts(JSContext *cx, JSScript *script);
|
|
|
|
extern JS_PUBLIC_API(void)
|
|
JS_DumpCompartmentPCCounts(JSContext *cx);
|
|
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_UnwrapObject(JSObject *obj);
|
|
|
|
extern JS_PUBLIC_API(JSObject *)
|
|
JS_UnwrapObjectAndInnerize(JSObject *obj);
|
|
|
|
/* Call the context debug handler on the topmost scripted frame. */
|
|
extern JS_FRIEND_API(JSBool)
|
|
js_CallContextDebugHandler(JSContext *cx);
|
|
|
|
#endif /* jsdbgapi_h___ */
|