/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- * * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is mozilla.org code. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Robert Ginda, * * Alternatively, the contents of this file may be used under the terms of * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #include "nsISupports.idl" %{ C++ #include "jsdebug.h" #include "nsAString.h" %} [ptr] native JSDContext(JSDContext); [ptr] native JSDObject(JSDObject); [ptr] native JSDProperty(JSDProperty); [ptr] native JSDScript(JSDScript); [ptr] native JSDStackFrameInfo(JSDStackFrameInfo); [ptr] native JSDThreadState(JSDThreadState); [ptr] native JSDValue(JSDValue); [ptr] native JSRuntime(JSRuntime); [ptr] native JSContext(JSContext); /* interfaces we declare in this file */ interface jsdIDebuggerService; interface jsdIFilter; interface jsdINestCallback; interface jsdIFilterEnumerator; interface jsdIContextEnumerator; interface jsdIScriptEnumerator; interface jsdIScriptHook; interface jsdIErrorHook; interface jsdIExecutionHook; interface jsdICallHook; interface jsdIEphemeral; interface jsdIPC; interface jsdIContext; interface jsdIStackFrame; interface jsdIScript; interface jsdIValue; interface jsdIObject; interface jsdIProperty; /** * Debugger service. It's not a good idea to have more than one active client of * the debugger service. */ [scriptable, uuid(01be7f9a-1dd2-11b2-9d55-aaf919b27c73)] interface jsdIDebuggerService : nsISupports { /** Internal use only. */ [noscript] readonly attribute JSDContext JSDContext; /** * Called when an error or warning occurs. */ attribute jsdIErrorHook errorHook; /** * Called when a jsdIScript is created or destroyed. */ attribute jsdIScriptHook scriptHook; /** * Called when the engine encounters a breakpoint. */ attribute jsdIExecutionHook breakpointHook; /** * Called when the engine encounters the debugger keyword. */ attribute jsdIExecutionHook debuggerHook; /** * Called when the errorHook returns false. */ attribute jsdIExecutionHook debugHook; /** * Called before the next PC is executed. */ attribute jsdIExecutionHook interruptHook; /** * Called when an exception is thrown (even if it will be caught.) */ attribute jsdIExecutionHook throwHook; /** * Called before and after a toplevel script is evaluated. */ attribute jsdICallHook topLevelHook; /** * Called before and after a function is called. */ attribute jsdICallHook functionHook; /** * VERSION_* values must be kept in sync with the JSVersion enumeration in * jspubtd.h. */ /** * Possible values for jsdIScript::version and jsdIContext::version. */ const long VERSION_1_0 = 100; const long VERSION_1_1 = 110; const long VERSION_1_2 = 120; const long VERSION_1_3 = 130; const long VERSION_1_4 = 140; const long VERSION_1_5 = 150; const long VERSION_DEFAULT = 0; const long VERSION_UNKNOWN = -1; /** * These flags need to be kept in sync with the context flags defined in * jsdebug.h */ /** * Link native frames in call stacks. */ const unsigned long ENABLE_NATIVE_FRAMES = 0x01; /** * Normally, if a script has a 0 in JSD_SCRIPT_PROFILE_BIT it is included in * profile data, otherwise it is not profiled. Setting the * PROFILE_WHEN_SET flag reverses this convention. */ const unsigned long PROFILE_WHEN_SET = 0x02; /** * Normally, when the script in the top frame of a thread state has a 1 in * JSD_SCRIPT_DEBUG_BIT, the execution hook is ignored. Setting the * DEBUG_WHEN_SET flag reverses this convention. */ const unsigned long DEBUG_WHEN_SET = 0x04; /** * When this flag is set the internal call hook will collect profile data. */ const unsigned long COLLECT_PROFILE_DATA = 0x08; /** * When this flag is set, stack frames that are disabled for debugging * will not appear in the call stack chain. */ const unsigned long HIDE_DISABLED_FRAMES = 0x10; /** * When this flag is set, the debugger will only check the * JSD_SCRIPT_DEBUG_BIT on the top (most recent) stack frame. This * makes it possible to stop in an enabled frame which was called from * a stack that contains a disabled frame. * * When this flag is *not* set, any stack that contains a disabled frame * will not be debugged (the execution hook will not be invoked.) * * This only applies when the reason for calling the hook would have * been TYPE_INTERRUPTED or TYPE_THROW. TYPE_BREAKPOINT, * TYPE_DEBUG_REQUESTED, and TYPE_DEBUGGER_KEYWORD always stop, regardless * of this setting, as long as the top frame is not disabled. * * If HIDE_DISABLED_FRAMES is set, this is effectively set as well. */ const unsigned long MASK_TOP_FRAME_ONLY = 0x20; /** * When this flag is set, object creation will not be tracked. This will * reduce the performance price you pay by enabling the debugger. */ const unsigned long DISABLE_OBJECT_TRACE = 0x40; /** * Debugger service flags. */ attribute unsigned long flags; /** * Major version number of implementation. */ readonly attribute unsigned long implementationMajor; /** * Minor version number of implementation. */ readonly attribute unsigned long implementationMinor; /** * Free form string identifier for implementation. */ readonly attribute string implementationString; /** * |true| if the debugger should register an app-start observer in order * to begin collecting debug information when mozilla is launched. */ attribute boolean initAtStartup; /** * |true| if the debugger service has been turned on. This does not * necessarily mean another app is actively using the service, as the * autostart pref may have turned the service on. */ readonly attribute boolean isOn; /** * Turn on the debugger. This function should only be called from JavaScript * code. The debugger will be enabled on the runtime the call is made on, * as determined by nsIXPCNativeCallContext. */ void on (); /** * Turn on the debugger for a given runtime. * * @param rt The runtime you want to debug. You cannot turn the debugger * on for multiple runtimes. */ [noscript] void onForRuntime (in JSRuntime rt); /** * Turn the debugger off. This will invalidate all of your jsdIEphemeral * derived objects, and clear all of your breakpoints. In theory you * should be able to turn the debugger back on at some later time without * any problems. */ void off (); /** * Peek at the current pause depth of the debugger. * * @return depth Number of pause() calls still waiting to be unPause()d. */ readonly attribute unsigned long pauseDepth; /** * Temporarily disable the debugger. Hooks will not be called while the * debugger is paused. Multiple calls to pause will increase the "pause * depth", and equal number of unPause calles must be made to resume * normal debugging. * * @return depth Number of times pause has been called since the debugger * has been unpaused. */ unsigned long pause(); /** * Undo a pause. * * @return depth The number of remaining pending pause calls. */ unsigned long unPause(); /** * Force the engine to perform garbage collection. */ void GC(); /** * Clear profile data for all scripts. */ void clearProfileData(); /** * Adds an execution hook filter. These filters are consulted each time one * of the jsdIExecutionHooks is about to be called. Filters are matched in * a first in, first compared fashion. The first filter to match determines * whether or not the hook is called. Use swapFilter to reorder existing * filters, and removeFilter to remove them. * * If |filter| is already present this method throws NS_ERROR_INVALID_ARG. * * @param filter Object representing the filter to add. * @param after Insert |filter| after this one. Pass null to insert at * the beginning. */ void insertFilter (in jsdIFilter filter, in jsdIFilter after); /** * Same as insertFilter, except always add to the end of the list. */ void appendFilter (in jsdIFilter filter); /** * Remove a filter. * * If |filter| is not present this method throws NS_ERROR_INVALID_ARG. * * @param filter Object representing the filter to remove. Must be the exact * object passed to addFilter, not just a new object with the same * properties. */ void removeFilter (in jsdIFilter filter); /** * Swap position of two filters. * * If |filter_a| is not present, this method throws NS_ERROR_INVALID_ARG. * If |filter_b| is not present, filter_a is replaced by filter_b. * If |filter_a| == |filter_b|, then filter is refreshed. */ void swapFilters (in jsdIFilter filter_a, in jsdIFilter filter_b); /** * Enumerate registered filters. This routine refreshes each filter before * passing them on to the enumeration function. Calling this with a null * |enumerator| is equivalent to jsdIService::refreshFilters. * * @param enumerator jsdIFilterEnumerator instance to be called back for the * enumeration. */ void enumerateFilters (in jsdIFilterEnumerator enumerator); /** * Force the debugger to resync its internal filter cache with the * actual values in the jsdIFilter objects. To refresh a single filter * use jsdIService::swapFilters. This method is equivalent to * jsdIService::enumerateFilters with a null enumerator. */ void refreshFilters (); /** * Clear the list of filters. */ void clearFilters(); /** * Enumerate all known contexts. */ void enumerateContexts (in jsdIContextEnumerator enumerator); /** * Enumerate all scripts the debugger knows about. Any scripts created * before you turned the debugger on, or after turning the debugger off * will not be available unless the autostart perf is set. * * @param enumerator jsdIScriptEnumerator instance to be called back for * the enumeration. */ void enumerateScripts (in jsdIScriptEnumerator enumerator); /** * Clear all breakpoints in all scripts. */ void clearAllBreakpoints (); /** * When called from JavaScript, this method returns the jsdIValue wrapper * for the given value. If a wrapper does not exist one will be created. * When called from another language this method returns an xpconnect * defined error code. */ jsdIValue wrapValue (/*in jsvalue value*/); /* XXX these two routines are candidates for refactoring. The only problem * is that it is not clear where and how they should land. */ /** * Push a new network queue, and enter a new UI event loop. * @param callback jsdINestCallback instance to be called back after the * network queue has been pushed, but before the * UI loop starts. * @return depth returns the current number of times the event loop has been * nested. your code can use it for sanity checks. */ unsigned long enterNestedEventLoop (in jsdINestCallback callback); /** * Exit the current nested event loop after the current iteration completes, * and pop the network event queue. * * @return depth returns the current number of times the event loop has been * nested. your code can use it for sanity checks. */ unsigned long exitNestedEventLoop (); }; /* callback interfaces */ /** * Object representing a pattern of global object and/or url the debugger should * ignore. The debugger service itself will not modify properties of these * objects. */ [scriptable, uuid(05593438-1b83-4517-864f-3cea3d37a266)] interface jsdIFilter : nsISupports { /** * These two bytes of the flags attribute are reserved for interpretation * by the jsdService implementation. You can do what you like with the * remaining flags. */ const unsigned long FLAG_RESERVED_MASK = 0xFF; /** * Filters without this flag set are ignored. */ const unsigned long FLAG_ENABLED = 0x01; /** * Filters with this flag set are "pass" filters, they allow matching hooks * to continue. Filters without this flag block matching hooks. */ const unsigned long FLAG_PASS = 0x02; /** * FLAG_* values from above, OR'd together. */ attribute unsigned long flags; /** * An nsISupports version of the global object to be filtered. A null glob * matches all hooks. This attribute must be QI'able to the * (non-scriptable) nsIScriptGlobalObject interface. * * The jsdIService caches this value internally, to if it changes you must * swap the filter with itself using jsdIService::swapFilters. */ attribute nsISupports globalObject; /** * String representing the url pattern to be filtered. Supports limited * glob matching, at the beginning and end of the pattern only. For example, * "chrome://venkman*" filters all urls that start with chrome/venkman, * "*.cgi" filters all cgi's, and "http://myserver/utils.js" filters only * the utils.js file on "myserver". A null urlPattern matches all urls. * * The jsdIService caches this value internally, to if it changes you must * swap the filter with itself using jsdIService::swapFilters. */ attribute string urlPattern; /** * Line number for the start of this filter. Line numbers are one based. * Assigning a 0 to this attribute will tell the debugger to ignore the * entire file. */ attribute unsigned long startLine; /** * Line number for the end of this filter. Line numbers are one based. * Assigning a 0 to this attribute will tell the debugger to ignore from * |startLine| to the end of the file. */ attribute unsigned long endLine; }; /** * Pass an instance of one of these to jsdIDebuggerService::enterNestedEventLoop. */ [scriptable, uuid(88bea60f-9b5d-4b39-b08b-1c3a278782c6)] interface jsdINestCallback : nsISupports { /** * This method will be called after pre-nesting work has completed, such * as pushing the js context and network event queue, but before the new * event loop starts. */ void onNest (); }; /** * Pass an instance of one of these to jsdIDebuggerService::enumerateFilters. */ [scriptable, uuid(54382875-ed12-4f90-9a63-1f0498d0a3f2)] interface jsdIFilterEnumerator : nsISupports { /** * The enumerateFilter method will be called once for every filter the * debugger knows about. */ void enumerateFilter (in jsdIFilter filter); }; /** * Pass an instance of one of these to jsdIDebuggerService::enumerateScripts. */ [scriptable, uuid(4c2f706e-1dd2-11b2-9ebc-85a06e948830)] interface jsdIScriptEnumerator : nsISupports { /** * The enumerateScript method will be called once for every script the * debugger knows about. */ void enumerateScript (in jsdIScript script); }; /** * Pass an instance of one of these to jsdIDebuggerService::enumerateContexts. */ [scriptable, uuid(912e342a-1dd2-11b2-b09f-cf3af38c15f0)] interface jsdIContextEnumerator : nsISupports { /** * The enumerateContext method will be called once for every context * currently in use. */ void enumerateContext (in jsdIContext executionContext); }; /** * Set jsdIDebuggerService::scriptHook to an instance of one of these. */ [scriptable, uuid(ae89a7e2-1dd1-11b2-8c2f-af82086291a5)] interface jsdIScriptHook : nsISupports { /** * Called when scripts are created. */ void onScriptCreated (in jsdIScript script); /** * Called when the JavaScript engine destroys a script. The jsdIScript * object passed in will already be invalidated. */ void onScriptDestroyed (in jsdIScript script); }; /** * Hook instances of this interface up to the * jsdIDebuggerService::functionHook and toplevelHook properties. */ [scriptable, uuid(f102caf6-1dd1-11b2-bd43-c1dbacb95a98)] interface jsdICallHook : nsISupports { /** * TYPE_* values must be kept in sync with the JSD_HOOK_* #defines * in jsdebug.h. */ /** * Toplevel script is starting. */ const unsigned long TYPE_TOPLEVEL_START = 0; /** * Toplevel script has completed. */ const unsigned long TYPE_TOPLEVEL_END = 1; /** * Function is being called. */ const unsigned long TYPE_FUNCTION_CALL = 2; /** * Function is returning. */ const unsigned long TYPE_FUNCTION_RETURN = 3; /** * Called before the JavaScript engine executes a top level script or calls * a function. */ void onCall (in jsdIStackFrame frame, in unsigned long type); }; [scriptable, uuid(b7dd3c1c-1dd1-11b2-83eb-8a857d199e0f)] interface jsdIErrorHook : nsISupports { /** * REPORT_* values must be kept in sync with JSREPORT_* #defines in * jsapi.h */ /** * Report is an error. */ const unsigned long REPORT_ERROR = 0x00; /** * Report is only a warning. */ const unsigned long REPORT_WARNING = 0x01; /** * Report represents an uncaught exception. */ const unsigned long REPORT_EXCEPTION = 0x02; /** * Report is due to strict mode. */ const unsigned long REPORT_STRICT = 0x04; /** * Called when the JavaScript engine encounters an error. Return |true| * to pass the error along, |false| to invoke the debugHook. */ boolean onError (in string message, in string fileName, in unsigned long line, in unsigned long pos, in unsigned long flags, in unsigned long errnum, in jsdIValue exc); }; /** * Hook instances of this interface up to the * jsdIDebuggerService::breakpointHook, debuggerHook, errorHook, interruptHook, * and throwHook properties. */ [scriptable, uuid(9a7b6ad0-1dd1-11b2-a789-fcfae96356a2)] interface jsdIExecutionHook : nsISupports { /** * TYPE_* values must be kept in sync with JSD_HOOK_* #defines in jsdebug.h. */ /** * Execution stopped because we're in single step mode. */ const unsigned long TYPE_INTERRUPTED = 0; /** * Execution stopped by a trap instruction (i.e. breakoint.) */ const unsigned long TYPE_BREAKPOINT = 1; /** * Error handler returned an "invoke debugger" value. */ const unsigned long TYPE_DEBUG_REQUESTED = 2; /** * Debugger keyword encountered. */ const unsigned long TYPE_DEBUGGER_KEYWORD = 3; /** * Exception was thrown. */ const unsigned long TYPE_THROW = 4; /** * RETURN_* values must be kept in sync with JSD_HOOK_RETURN_* #defines in * jsdebug.h. */ /** * Indicates unrecoverable error processing the hook. This will cause * the script being executed to be aborted without raising a JavaScript * exception. */ const unsigned long RETURN_HOOK_ERROR = 0; /** * Continue processing normally. This is the "do nothing special" return * value for all hook types *except* TYPE_THROW. Returning RETURN_CONTINUE * from TYPE_THROW cause the exception to be ignored. Return * RETURN_CONTINUE_THROW to continue exception processing from TYPE_THROW * hooks. */ const unsigned long RETURN_CONTINUE = 1; /** * Same effect as RETURN_HOOK_ERROR. */ const unsigned long RETURN_ABORT = 2; /** * Return the value of the |val| parameter. */ const unsigned long RETURN_RET_WITH_VAL = 3; /** * Throw the value of the |val| parameter. */ const unsigned long RETURN_THROW_WITH_VAL = 4; /** * Continue the current throw. */ const unsigned long RETURN_CONTINUE_THROW = 5; /** * @param frame A jsdIStackFrame object representing the bottom stack frame. * @param type One of the jsdIExecutionHook::TYPE_ constants. * @param val in - Current exception (if any) when this method is called. * out - If you return RETURN_THROW_WITH_VAL, value to be * thrown. * If you return RETURN_RET_WITH_VAL, value to return. * All other return values, not significant. * @retval One of the jsdIExecutionHook::RETURN_* constants. */ unsigned long onExecute (in jsdIStackFrame frame, in unsigned long type, inout jsdIValue val); }; /** * Objects which inherit this interface may go away, with (jsdIScript) or * without (all others) notification. These objects are generally wrappers * around JSD structures that go away when you call jsdService::Off(). */ [scriptable, uuid(46f1e23e-1dd2-11b2-9ceb-8285f2e95e69)] interface jsdIEphemeral : nsISupports { /** * |true| if this object is still valid. If not, many or all of the methods * and/or properties of the inheritor may no longer be callable. */ readonly attribute boolean isValid; /** * Mark this instance as invalid. */ [noscript] void invalidate(); }; /* handle objects */ /** * Context object. Only context's which are also nsISupports objects can be * reflected by this interface. */ [scriptable, uuid(a2dd25a4-1dd1-11b2-bda6-ed525acd4c35)] interface jsdIContext : jsdIEphemeral { /* Internal use only. */ [noscript] readonly attribute JSContext JSContext; /** * OPT_* values must be kept in sync with JSOPTION_* #defines in jsapi.h. */ /** * Strict mode is on. */ const long OPT_STRICT = 0x01; /** * Warnings reported as errors. */ const long OPT_WERR = 0x02; /** * Makes eval() use the last object on its 'obj' param's scope chain as the * ECMA 'variables object'. */ const long OPT_VAROBJFIX = 0x04; /** * Private data for this object is an nsISupports object. Attempting to * alter this bit will result in an NS_ERROR_ILLEGAL_VALUE. */ const long OPT_ISUPPORTS = 0x08; /** * OPT_* values above, OR'd together. */ attribute unsigned long options; /** * Last version set on this context. * Scripts typically select this with the "language" attribute. * See the VERSION_* consts on jsdIDebuggerService. */ attribute long version; /** * Unique tag among all valid jsdIContext objects, useful as a hash key. */ readonly attribute unsigned long tag; /** * Private data for this context, if it is an nsISupports, |null| otherwise. */ readonly attribute nsISupports privateData; /** * Retrieve the underlying context wrapped by this jsdIContext. */ readonly attribute nsISupports wrappedContext; /** * Top of the scope chain for this context. */ readonly attribute jsdIValue globalObject; /** * |true| if this context should be allowed to run scripts, |false| * otherwise. This attribute is only valid for contexts which implement * nsIScriptContext. Setting or getting this attribute on any other * context will throw a NS_ERROR_NO_INTERFACE exception. */ attribute boolean scriptsEnabled; }; /** * Stack frame objects. These are only valid inside the jsdIExecutionHook which * gave it to you. After you return from that handler the bottom frame, and any * frame you found attached through it, are invalidated via the jsdIEphemeral * interface. Once a jsdIStackFrame has been invalidated all method and * property accesses will throw a NS_ERROR_NOT_AVAILABLE exception. */ [scriptable, uuid(b6d50784-1dd1-11b2-a932-882246c6fe45)] interface jsdIStackFrame : jsdIEphemeral { /** Internal use only. */ [noscript] readonly attribute JSDContext JSDContext; /** Internal use only. */ [noscript] readonly attribute JSDThreadState JSDThreadState; /** Internal use only. */ [noscript] readonly attribute JSDStackFrameInfo JSDStackFrameInfo; /** * True if stack frame represents a native frame. */ readonly attribute boolean isNative; /** * True if stack frame represents a frame created as a result of a debugger * evaluation. */ readonly attribute boolean isDebugger; /** * True if stack frame is constructing a new object. */ readonly attribute boolean isConstructing; /** * Link to the caller's stack frame. */ readonly attribute jsdIStackFrame callingFrame; /** * Executon context. */ readonly attribute jsdIContext executionContext; /** * Function name executing in this stack frame. */ readonly attribute string functionName; /** * Script running in this stack frame, null for native frames. */ readonly attribute jsdIScript script; /** * Current program counter in this stack frame. */ readonly attribute unsigned long pc; /** * Current line number (using the script's pc to line map.) */ readonly attribute unsigned long line; /** * Function object running in this stack frame. */ readonly attribute jsdIValue callee; /** * Top object in the scope chain. */ readonly attribute jsdIValue scope; /** * |this| object for this stack frame. */ readonly attribute jsdIValue thisValue; /** * Evaluate arbitrary JavaScript in this stack frame. * @param bytes Script to be evaluated. * @param fileName Filename to compile this script under. This is the * filename you'll see in error messages, etc. * @param line Starting line number for this script. One based. * @retval Result of evaluating the script. */ boolean eval (in AString bytes, in string fileName, in unsigned long line, out jsdIValue result); }; /** * Script object. In JavaScript engine terms, there's a single script for each * function, and one for the top level script. */ [scriptable, uuid(a38f65ca-1dd1-11b2-95d5-ff2947e9c920)] interface jsdIScript : jsdIEphemeral { /** Internal use only. */ [noscript] readonly attribute JSDContext JSDContext; /** Internal use only. */ [noscript] readonly attribute JSDScript JSDScript; /** * Last version set on this context. * Scripts typically select this with the "language" attribute. * See the VERSION_* consts on jsdIDebuggerService. */ readonly attribute long version; /** * Tag value guaranteed unique among jsdIScript objects. Useful as a * hash key in script. */ readonly attribute unsigned long tag; /** * FLAG_* values need to be kept in sync with JSD_SCRIPT_* #defines in * jsdebug.h. */ /** * Determines whether or not to collect profile information for this * script. The context flag FLAG_PROFILE_WHEN_SET decides the logic. */ const unsigned long FLAG_PROFILE = 0x01; /** * Determines whether or not to ignore breakpoints, etc. in this script. * The context flag JSD_DEBUG_WHEN_SET decides the logic. */ const unsigned long FLAG_DEBUG = 0x02; /** * FLAG_* attributes from above, OR'd together. */ attribute unsigned long flags; /** * Filename given for this script when it was compiled. * This data is copied from the underlying structure when the jsdIScript * instance is created and is therefore available even after the script is * invalidated. */ readonly attribute string fileName; /** * Function name for this script. "anonymous" for unnamed functions (or * a function actually named anonymous), empty for top level scripts. * This data is copied from the underlying structure when the jsdIScript * instance is created and is therefore available even after the script is * invalidated. */ readonly attribute string functionName; /** * Fetch the function object as a jsdIValue. */ readonly attribute jsdIValue functionObject; /** * Source code for this script, without function declaration. */ readonly attribute AString functionSource; /** * Line number in source file containing the first line of this script. * This data is copied from the underlying structure when the jsdIScript * instance is created and is therefore available even after the script is * invalidated. */ readonly attribute unsigned long baseLineNumber; /** * Total number of lines in this script. * This data is copied from the underlying structure when the jsdIScript * instance is created and is therefore available even after the script is * invalidated. */ readonly attribute unsigned long lineExtent; /** * Number of times this script has been called. */ readonly attribute unsigned long callCount; /** * Number of times this script called itself, directly or indirectly. */ readonly attribute unsigned long maxRecurseDepth; /** * Shortest execution time recorded, in milliseconds. */ readonly attribute double minExecutionTime; /** * Longest execution time recorded, in milliseconds. */ readonly attribute double maxExecutionTime; /** * Total time spent in this function, in milliseconds. */ readonly attribute double totalExecutionTime; /** * Clear profile data for this script. */ void clearProfileData(); const unsigned long PCMAP_SOURCETEXT = 1; /* map to actual source text */ const unsigned long PCMAP_PRETTYPRINT = 2; /* map to pretty printed source */ /** * Get the closest line number to a given PC. * The |pcmap| argument specifies which pc to source line map to use. */ unsigned long pcToLine (in unsigned long pc, in unsigned long pcmap); /** * Get the first PC associated with a line. * The |pcmap| argument specifies which pc to source line map to use. */ unsigned long lineToPc (in unsigned long line, in unsigned long pcmap); /** * Determine is a particular line is executable, like checking that * lineToPc == pcToLine, except in one call. * The |pcmap| argument specifies which pc to source line map to use. */ boolean isLineExecutable (in unsigned long line, in unsigned long pcmap); /** * Set a breakpoint at a PC in this script. */ void setBreakpoint (in unsigned long pc); /** * Clear a breakpoint at a PC in this script. */ void clearBreakpoint (in unsigned long pc); /** * Clear all breakpoints set in this script. */ void clearAllBreakpoints (); }; /** * Value objects. Represents typeless JavaScript values (jsval in SpiderMonkey * terminology.) These are valid until the debugger is turned off. Holding a * jsdIValue adds a root for the underlying JavaScript value, so don't keep it * if you don't need to. */ [scriptable, uuid(b7964304-1dd1-11b2-ba20-cf4205772e9d)] interface jsdIValue : jsdIEphemeral { /** Internal use only. */ [noscript] readonly attribute JSDContext JSDContext; /** Internal use only. */ [noscript] readonly attribute JSDValue JSDValue; /** * |false| unless the value is a function declared in script. */ readonly attribute boolean isNative; /** * |true| if the value represents a number, either double or integer. * |false| for all other values, including numbers assigned as strings * (eg. x = "1";) */ readonly attribute boolean isNumber; /** * |true| if the value represents a JavaScript primitive number or string */ readonly attribute boolean isPrimitive; /** Value is either |true| or |false|. */ const unsigned long TYPE_BOOLEAN = 0; /** Value is a primitive number that is too large to fit in an integer. */ const unsigned long TYPE_DOUBLE = 1; /** Value is a primitive number that fits into an integer. */ const unsigned long TYPE_INT = 2; /** Value is a function. */ const unsigned long TYPE_FUNCTION = 3; /** Value is |null|. */ const unsigned long TYPE_NULL = 4; /** Value is an object. */ const unsigned long TYPE_OBJECT = 5; /** Value is a primitive string. */ const unsigned long TYPE_STRING = 6; /** Value is void. */ const unsigned long TYPE_VOID = 7; /** * One of the TYPE_* values above. */ readonly attribute unsigned long jsType; /** * Prototype value if this value represents an object, null if the value is * not an object or the object has no prototype. */ readonly attribute jsdIValue jsPrototype; /** * Parent value if this value represents an object, null if the value is not * an object or the object has no parent. */ readonly attribute jsdIValue jsParent; /** * Class name if this value represents an object. Empty string if the value * is not an object. */ readonly attribute string jsClassName; /** * Constructor name if this value represents an object. Empty string if the * value is not an object. */ readonly attribute jsdIValue jsConstructor; /** * Function name if this value represents a function. Empty string if the * value is not a function. */ readonly attribute string jsFunctionName; /** * Value if interpreted as a boolean. Converts if necessary. */ readonly attribute boolean booleanValue; /** * Value if interpreted as a double. Converts if necessary. */ readonly attribute double doubleValue; /** * Value if interpreted as an integer. Converts if necessary. */ readonly attribute long intValue; /** * Value if interpreted as an object. */ readonly attribute jsdIObject objectValue; /** * Value if interpreted as a string. Converts if necessary. */ readonly attribute string stringValue; /** * Number of properties. 0 if the value is not an object, or the value is * an object but has no properties. */ readonly attribute long propertyCount; /** * Retrieves all properties if this value represents an object. If this * value is not an object a 0 element array is returned. * @param propArray Array of jsdIProperty values for this value. * @param length Size of array. */ void getProperties ([array, size_is(length)] out jsdIProperty propArray, out unsigned long length); /** * Retrieves a single property from the value. Only valid if the value * represents an object. * @param name Name of the property to retrieve. * @retval jsdIProperty for the requested property name or null if no * property exists for the requested name. */ jsdIProperty getProperty (in string name); /** * jsdIValues are wrappers around JavaScript engine structures. Much of the * data is copied instead of shared. The refresh method is used to resync * the jsdIValue with the underlying structure. */ void refresh(); /** * When called from JavaScript, this method returns the JavaScript value * wrapped by this jsdIValue. The calling script is free to use the result * as it would any other JavaScript value. * When called from another language this method returns an xpconnect * defined error code. */ void getWrappedValue(); }; /** * Properties specific to values which are also objects. * XXX We don't add roots for these yet, so make sure you hold on to the * jsdIValue from whence your jsdIObject instance came for at least as long as * you hold the jsdIObject. * XXX Maybe the jsClassName, jsConstructorName, and property related attribute/ * functions from jsdIValue should move to this interface. We could inherit from * jsdIValue or use interface flattening or something. */ [scriptable, uuid(d500e8b8-1dd1-11b2-89a1-cdf55d91cbbd)] interface jsdIObject : nsISupports { /** Internal use only. */ [noscript] readonly attribute JSDContext JSDContext; /** Internal use only. */ [noscript] readonly attribute JSDObject JSDObject; /** * The URL (filename) that contains the script which caused this object * to be created. */ readonly attribute string creatorURL; /** * Line number in the creatorURL where this object was created. */ readonly attribute unsigned long creatorLine; /** * The URL (filename) that contains the script which defined the constructor * used to create this object. */ readonly attribute string constructorURL; /** * Line number in the creatorURL where this object was created. */ readonly attribute unsigned long constructorLine; /** * jsdIValue for this object. */ readonly attribute jsdIValue value; }; /** * Representation of a property of an object. When an instance is invalid, all * method and property access will result in a NS_UNAVAILABLE error. */ [scriptable, uuid(b8816e56-1dd1-11b2-81dc-8ba99a833d9e)] interface jsdIProperty : jsdIEphemeral { /** Internal use only. */ [noscript] readonly attribute JSDContext JSDContext; /** Internal use only. */ [noscript] readonly attribute JSDProperty JSDProperty; /** * FLAG_* values must be kept in sync with JSDPD_* #defines in jsdebug.h. */ /** visible to for/in loop */ const unsigned long FLAG_ENUMERATE = 0x01; /** assignment is error */ const unsigned long FLAG_READONLY = 0x02; /** property cannot be deleted */ const unsigned long FLAG_PERMANENT = 0x04; /** property has an alias id */ const unsigned long FLAG_ALIAS = 0x08; /** argument to function */ const unsigned long FLAG_ARGUMENT = 0x10; /** local variable in function */ const unsigned long FLAG_VARIABLE = 0x20; /** exception occurred looking up property, value is exception */ const unsigned long FLAG_EXCEPTION = 0x40; /** native getter returned JS_FALSE without throwing an exception */ const unsigned long FLAG_ERROR = 0x80; /** found via explicit lookup (property defined elsewhere.) */ const unsigned long FLAG_HINTED = 0x800; /** FLAG_* values OR'd together, representing the flags for this property. */ readonly attribute unsigned long flags; /** jsdIValue representing the alias for this property. */ readonly attribute jsdIValue alias; /** name for this property. */ readonly attribute jsdIValue name; /** value of this property. */ readonly attribute jsdIValue value; /** slot number if this property is a local variable or parameter. */ readonly attribute unsigned long varArgSlot; }; /* [scriptable, uuid(a47adad2-1dd1-11b2-b9e9-8e67a47beca5)] interface jsdISourceText : nsISupports {}; [scriptable, uuid(b6d1c006-1dd1-11b2-b9d8-b4d1ccfb74d8)] interface jsdIThreadState : nsISupports { [noscript] readonly attribute JSDContext JSDContext; [noscript] readonly attribute JSDThreadState JSDThreadState; readonly attribute unsigned long frameCount; readonly attribute jsdIStackFrame topFrame; attribute jsdIValue pendingException; }; */