Project: Firebug

Revision: 302

Author: johnjbarton.com

Date: 08 Dec 2007 20:14:18

• /trunk/components/firebug-service.js

  ......	@@ -1,1281 +1,2007 @@
  1		/* See license.txt for terms of usage */
  2
  3		// ************************************************************************************************
  4		// Utils
  5
  6		function CC(className)
  7		{
  8		return Components.classes[className];
  9		}
  10
  11		function CI(ifaceName)
  12		{
  13		return Components.interfaces[ifaceName];
  14		}
  15
  16		// ************************************************************************************************
  17		// Constants
  18
  19		const CLASS_ID = Components.ID("{a380e9c0-cb39-11da-a94d-0800200c9a66}");
  20		const CLASS_NAME = "Firebug Service";
  21		const CONTRACT_ID = "@joehewitt.com/firebug;1";
  22
  23		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  24
  25		const PrefService = CC("@mozilla.org/preferences-service;1");
  26		const DebuggerService = CC("@mozilla.org/js/jsd/debugger-service;1");
  27		const ConsoleService = CC("@mozilla.org/consoleservice;1");
  28		const Timer = CC("@mozilla.org/timer;1");
  29
  30		const jsdIDebuggerService = CI("jsdIDebuggerService");
  31		const jsdIScript = CI("jsdIScript");
  32		const jsdIStackFrame = CI("jsdIStackFrame");
  33		const jsdICallHook = CI("jsdICallHook");
  34		const jsdIExecutionHook = CI("jsdIExecutionHook");
  35		const nsIFireBug = CI("nsIFireBug");
  36		const nsIPrefBranch2 = CI("nsIPrefBranch2");
  37		const nsIComponentRegistrar = CI("nsIComponentRegistrar");
  38		const nsIFactory = CI("nsIFactory");
  39		const nsIConsoleService = CI("nsIConsoleService");
  40		const nsITimer = CI("nsITimer");
  41
  42		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  43
  44		const NS_ERROR_NO_INTERFACE = Components.results.NS_ERROR_NO_INTERFACE;
  45		const NS_ERROR_NOT_IMPLEMENTED = Components.results.NS_ERROR_NOT_IMPLEMENTED;
  46		const NS_ERROR_NO_AGGREGATION = Components.results.NS_ERROR_NO_AGGREGATION;
  47
  48		const PCMAP_SOURCETEXT = jsdIScript.PCMAP_SOURCETEXT;
  49
  50		const COLLECT_PROFILE_DATA = jsdIDebuggerService.COLLECT_PROFILE_DATA;
  51		const DISABLE_OBJECT_TRACE = jsdIDebuggerService.DISABLE_OBJECT_TRACE;
  52
  53		const TYPE_FUNCTION_CALL = jsdICallHook.TYPE_FUNCTION_CALL;
  54		const TYPE_FUNCTION_RETURN = jsdICallHook.TYPE_FUNCTION_RETURN;
  55
  56		const RETURN_CONTINUE = jsdIExecutionHook.RETURN_CONTINUE;
  57		const RETURN_VALUE = jsdIExecutionHook.RETURN_RET_WITH_VAL;
  58		const RETURN_CONTINUE_THROW = jsdIExecutionHook.RETURN_CONTINUE_THROW;
  59
  60		const STEP_OVER = nsIFireBug.STEP_OVER;
  61		const STEP_INTO = nsIFireBug.STEP_INTO;
  62		const STEP_OUT = nsIFireBug.STEP_OUT;
  63
  64		const TYPE_ONE_SHOT = nsITimer.TYPE_ONE_SHOT;
  65
  66		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  67
  68		const BP_NORMAL = 1;
  69		const BP_MONITOR = 2;
  70		const BP_UNTIL = 4;
  71
  72		// ************************************************************************************************
  73		// Globals
  74
  75		var jsd, fbs, prefs;
  76
  77		var contextCount = 0;
  78
  79		var clients = [];
  80		var debuggers = [];
  81		var scriptMap = {};
  82
  83		var stepMode = 0;
  84		var stepFrame;
  85		var stepFrameLineId;
  86		var stepFrameCount;
  87		var hookFrameCount;
  88
  89		var haltDebugger = null;
  90
  91		var breakpoints = {};
  92		var breakpointCount = 0;
  93		var disabledCount = 0;
  94		var monitorCount = 0;
  95		var conditionCount = 0;
  96		var runningUntil = null;
  97
  98		var errorBreakpoints = [];
  99
  100		var profileCount = 0;
  101		var profileStart;
  102
  103		var enabledDebugger = false;
  104		var reportNextError = false;
  105		var breakOnNextError = false;
  106
  107		var timer = Timer.createInstance(nsITimer);
  108		var waitingForTimer = false;
  109
  110		// ************************************************************************************************
  111
  112		function FirebugService()
  113		{
  114		fbs = this;
  115
  116		this.enabled = false;
  117		this.profiling = false;
  118
  119		prefs = PrefService.getService(nsIPrefBranch2);
  120		prefs.addObserver("extensions.firebug", FirebugPrefsObserver, false);
  121
  122		var observerService = CC("@mozilla.org/observer-service;1")
  123		.getService(CI("nsIObserverService"));
  124		observerService.addObserver(ShutdownObserver, "quit-application", false);
  125
  126		this.showStackTrace = prefs.getBoolPref("extensions.firebug.showStackTrace");
  127		this.breakOnErrors = prefs.getBoolPref("extensions.firebug.breakOnErrors");
  128		}
  129
  130		FirebugService.prototype =
  131		{
  132		shutdown: function()
  133		{
  134		timer = null;
  135		fbs = null;
  136		jsd = null;
  137		},
  138
  139		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  140		// nsISupports
  141
  142		QueryInterface: function(iid)
  143		{
  144		if (!iid.equals(nsIFireBug) && !iid.equals(nsISupports))
  145		throw NS_ERROR_NO_INTERFACE;
  146
  147		return this;
  148		},
  149
  150		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  151		// nsIFireBug
  152
  153		get lastErrorWindow()
  154		{
  155		var win = this._lastErrorWindow;
  156		this._lastErrorWindow = null; // Release to avoid leaks
  157		return win;
  158		},
  159
  160		countContext: function(on)
  161		{
  162		contextCount += on ? 1 : -1;
  163
  164		if (on && contextCount == 1)
  165		{
  166		this.enabled = true;
  167		dispatch(clients, "enable");
  168		}
  169		else if (contextCount == 0)
  170		{
  171		this.enabled = false;
  172		dispatch(clients, "disable");
  173		}
  174
  175		return true;
  176		},
  177
  178		registerClient: function(client)
  179		{
  180		clients.push(client);
  181		},
  182
  183		unregisterClient: function(client)
  184		{
  185		for (var i = 0; i < clients.length; ++i)
  186		{
  187		if (clients[i] == client)
  188		{
  189		clients.splice(i, 1);
  190		break;
  191		}
  192		}
  193		},
  194
  195		registerDebugger: function(debuggr)
  196		{
  197		this.enableDebugger();
  198
  199		debuggers.push(debuggr);
  200		},
  201
  202		unregisterDebugger: function(debuggr)
  203		{
  204		for (var i = 0; i < debuggers.length; ++i)
  205		{
  206		if (debuggers[i] == debuggr)
  207		{
  208		debuggers.splice(i, 1);
  209		break;
  210		}
  211		}
  212
  213		if (!debuggers.length)
  214		this.disableDebugger();
  215		},
  216
  217		lockDebugger: function()
  218		{
  219		if (this.locked)
  220		return;
  221
  222		this.locked = true;
  223
  224		dispatch(debuggers, "onLock", [true]);
  225		},
  226
  227		unlockDebugger: function()
  228		{
  229		if (!this.locked)
  230		return;
  231
  232		this.locked = false;
  233
  234		dispatch(debuggers, "onLock", [false]);
  235		},
  236
  237		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  238
  239		halt: function(debuggr)
  240		{
  241		haltDebugger = debuggr;
  242		},
  243
  244		step: function(mode, startFrame)
  245		{
  246		stepMode = mode;
  247		stepFrame = startFrame;
  248		stepFrameCount = countFrames(startFrame);
  249		stepFrameLineId = stepFrameCount + startFrame.script.fileName + startFrame.line;
  250		},
  251
  252		runUntil: function(url, lineNo, startFrame)
  253		{
  254		runningUntil = this.addBreakpoint(BP_UNTIL, url, lineNo);
  255		stepFrameCount = countFrames(startFrame);
  256		stepFrameLineId = stepFrameCount + startFrame.script.fileName + startFrame.line;
  257		},
  258
  259		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  260
  261		setBreakpoint: function(url, lineNo)
  262		{
  263		if (this.addBreakpoint(BP_NORMAL, url, lineNo))
  264		dispatch(debuggers, "onToggleBreakpoint", [url, lineNo, true]);
  265		},
  266
  267		clearBreakpoint: function(url, lineNo)
  268		{
  269		if (this.removeBreakpoint(BP_NORMAL, url, lineNo))
  270		dispatch(debuggers, "onToggleBreakpoint", [url, lineNo, false]);
  271		},
  272
  273		enableBreakpoint: function(url, lineNo)
  274		{
  275		url = denormalizeURL(url);
  276
  277		var bp = this.findBreakpoint(url, lineNo);
  278		if (bp && bp.type & BP_NORMAL)
  279		{
  280		bp.disabled &= ~BP_NORMAL;
  281		dispatch(debuggers, "onToggleBreakpointDisabled", [url, lineNo, false]);
  282		--disabledCount;
  283		}
  284		},
  285
  286		disableBreakpoint: function(url, lineNo)
  287		{
  288		url = denormalizeURL(url);
  289
  290		var bp = this.findBreakpoint(url, lineNo);
  291		if (bp && bp.type & BP_NORMAL)
  292		{
  293		bp.disabled |= BP_NORMAL;
  294		++disabledCount;
  295		dispatch(debuggers, "onToggleBreakpointDisabled", [url, lineNo, true]);
  296		}
  297		},
  298
  299		isBreakpointDisabled: function(url, lineNo)
  300		{
  301		url = denormalizeURL(url);
  302
  303		var bp = this.findBreakpoint(url, lineNo);
  304		if (bp && bp.type & BP_NORMAL)
  305		return bp.disabled & BP_NORMAL;
  306		else
  307		return false;
  308		},
  309
  310		setBreakpointCondition: function(url, lineNo, condition)
  311		{
  312		url = denormalizeURL(url);
  313		var bp = this.findBreakpoint(url, lineNo);
  314		if (!bp)
  315		{
  316		bp = this.addBreakpoint(BP_NORMAL, url, lineNo);
  317		if (bp)
  318		dispatch(debuggers, "onToggleBreakpoint", [url, lineNo, true]);
  319		}
  320
  321		if (!bp)
  322		return;
  323
  324		if (bp.condition && !condition)
  325		{
  326		--conditionCount;
  327		dispatch(debuggers, "onToggleBreakpointCondition", [url, lineNo, false]);
  328		}
  329		else if (condition && !bp.condition)
  330		{
  331		++conditionCount;
  332		dispatch(debuggers, "onToggleBreakpointCondition", [url, lineNo, true]);
  333		}
  334
  335		bp.condition = condition;
  336		},
  337
  338		getBreakpointCondition: function(url, lineNo)
  339		{
  340		url = denormalizeURL(url);
  341		var bp = this.findBreakpoint(url, lineNo);
  342		return bp ? bp.condition : "";
  343		},
  344
  345		clearAllBreakpoints: function(urlCount, urls)
  346		{
  347		for (var i = 0; i < urls.length; ++i)
  348		{
  349		var url = denormalizeURL(urls[i]);
  350		var urlBreakpoints = breakpoints[url];
  351		if (!urlBreakpoints)
  352		continue;
  353
  354		urlBreakpoints = urlBreakpoints.slice();
  355		for (var j = 0; j < urlBreakpoints.length; ++j)
  356		{
  357		var bp = urlBreakpoints[j];
  358		this.clearBreakpoint(url, bp.lineNo);
  359		}
  360		}
  361		},
  362
  363		hasBreakpoint: function(script)
  364		{
  365		var url = script.fileName;
  366		var lineNo = findExecutableLine(script, script.baseLineNumber);
  367
  368		var urlBreakpoints = breakpoints[url];
  369		if (urlBreakpoints)
  370		{
  371		for (var i = 0; i < urlBreakpoints.length; ++i)
  372		{
  373		var bp = urlBreakpoints[i];
  374		if (bp.lineNo == lineNo && bp.type & BP_NORMAL)
  375		return true;
  376		}
  377		}
  378
  379		return false;
  380		},
  381
  382		enumerateBreakpoints: function(url, cb)
  383		{
  384		if (url)
  385		{
  386		url = denormalizeURL(url);
  387
  388		var urlBreakpoints = breakpoints[url];
  389		if (urlBreakpoints)
  390		{
  391		for (var i = 0; i < urlBreakpoints.length; ++i)
  392		{
  393		var bp = urlBreakpoints[i];
  394		if (bp.type & BP_NORMAL)
  395		cb.call(url, bp.lineNo, bp.startLineNo, bp.disabled & BP_NORMAL,
  396		bp.condition);
  397		}
  398		}
  399		}
  400		else
  401		{
  402		for (var url in breakpoints)
  403		this.enumerateBreakpoints(url, cb);
  404		}
  405		},
  406
  407		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  408
  409		setErrorBreakpoint: function(url, lineNo)
  410		{
  411		var index = this.findErrorBreakpoint(url, lineNo);
  412		if (index == -1)
  413		{
  414		var scripts = this.findScripts(denormalizeURL(url), lineNo);
  415		if (scripts.length)
  416		{
  417		errorBreakpoints.push({href: normalizeURL(url), lineNo: lineNo,
  418		startLineNo: scripts[0].baseLineNumber});
  419		dispatch(debuggers, "onToggleErrorBreakpoint", [url, lineNo, true]);
  420		}
  421		}
  422		},
  423
  424		clearErrorBreakpoint: function(url, lineNo)
  425		{
  426		var index = this.findErrorBreakpoint(url, lineNo);
  427		if (index != -1)
  428		{
  429		errorBreakpoints.splice(index, 1);
  430
  431		dispatch(debuggers, "onToggleErrorBreakpoint", [url, lineNo, false]);
  432		}
  433		},
  434
  435		hasErrorBreakpoint: function(url, lineNo)
  436		{
  437		return this.findErrorBreakpoint(url, lineNo) != -1;
  438		},
  439
  440		enumerateErrorBreakpoints: function(url, cb)
  441		{
  442		if (url)
  443		{
  444		url = normalizeURL(url);
  445		for (var i = 0; i < errorBreakpoints.length; ++i)
  446		{
  447		var bp = errorBreakpoints[i];
  448		if (bp.href == url)
  449		cb.call(bp.href, bp.lineNo, bp.startLineNo, false, "");
  450		}
  451		}
  452		else
  453		{
  454		for (var i = 0; i < errorBreakpoints.length; ++i)
  455		{
  456		var bp = errorBreakpoints[i];
  457		cb.call(bp.href, bp.lineNo, bp.startLineNo, false, "");
  458		}
  459		}
  460		},
  461
  462		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  463
  464		monitor: function(script, debuggr)
  465		{
  466		var lineNo = findExecutableLine(script, script.baseLineNumber);
  467		if (lineNo != -1 && this.addBreakpoint(BP_MONITOR, script.fileName, lineNo, debuggr, script))
  468		{
  469		++monitorCount;
  470		dispatch(debuggers, "onToggleMonitor", [script.fileName, lineNo, true]);
  471		}
  472		},
  473
  474		unmonitor: function(script)
  475		{
  476		var lineNo = findExecutableLine(script, script.baseLineNumber);
  477		if (lineNo != -1 && this.removeBreakpoint(BP_MONITOR, script.fileName, lineNo, script))
  478		{
  479		--monitorCount;
  480		dispatch(debuggers, "onToggleMonitor", [script.fileName, lineNo, false]);
  481		}
  482		},
  483
  484		isMonitored: function(script)
  485		{
  486		var lineNo = findExecutableLine(script, script.baseLineNumber);
  487		var bp = lineNo != -1 ? this.findBreakpoint(script.fileName, lineNo) : null;
  488		return bp && bp.type & BP_MONITOR;
  489		},
  490
  491		enumerateMonitors: function(url, cb)
  492		{
  493		if (url)
  494		{
  495		url = denormalizeURL(url);
  496
  497		var urlBreakpoints = breakpoints[url];
  498		if (urlBreakpoints)
  499		{
  500		for (var i = 0; i < urlBreakpoints.length; ++i)
  501		{
  502		var bp = urlBreakpoints[i];
  503		if (bp.type & BP_MONITOR)
  504		cb.call(url, bp.lineNo, bp.startLineNo, false, "");
  505		}
  506		}
  507		}
  508		else
  509		{
  510		for (var url in breakpoints)
  511		this.enumerateBreakpoints(url, cb);
  512		}
  513		},
  514
  515		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  516
  517		startProfiling: function()
  518		{
  519		if (!this.profiling)
  520		{
  521		this.profiling = true;
  522		profileStart = new Date();
  523
  524		jsd.flags |= COLLECT_PROFILE_DATA;
  525		}
  526
  527		++profileCount;
  528		},
  529
  530		stopProfiling: function()
  531		{
  532		if (--profileCount == 0)
  533		{
  534		jsd.flags &= ~COLLECT_PROFILE_DATA;
  535
  536		var t = profileStart.getTime();
  537
  538		this.profiling = false;
  539		profileStart = null;
  540
  541		return new Date().getTime() - t;
  542		}
  543		else
  544		return -1;
  545		},
  546
  547		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  548
  549		enableDebugger: function()
  550		{
  551		if (waitingForTimer)
  552		{
  553		timer.cancel();
  554		waitingForTimer = false;
  555		}
  556
  557		if (enabledDebugger)
  558		return;
  559
  560		enabledDebugger = true;
  561
  562		if (jsd)
  563		{
  564		jsd.unPause();
  565		this.hookScripts();
  566		}
  567		else
  568		{
  569		jsd = DebuggerService.getService(jsdIDebuggerService);
  570
  571		jsd.flags |= DISABLE_OBJECT_TRACE;
  572
  573		jsd.on();
  574		this.hookScripts();
  575
  576		jsd.debuggerHook = { onExecute: hook(this.onDebugger, RETURN_CONTINUE) };
  577		jsd.debugHook = { onExecute: hook(this.onDebug, RETURN_CONTINUE) };
  578		jsd.breakpointHook = { onExecute: hook(this.onBreakpoint, RETURN_CONTINUE_THROW) };
  579		//jsd.throwHook = { onExecute: hook(this.onThrow, RETURN_CONTINUE) };
  580		jsd.errorHook = { onError: hook(this.onError, true) };
  581		}
  582		},
  583
  584		disableDebugger: function()
  585		{
  586		if (!enabledDebugger)
  587		return;
  588
  589		timer.init({observe: function()
  590		{
  591		enabledDebugger = false;
  592
  593		jsd.pause();
  594		fbs.unhookScripts();
  595		}}, 1000, TYPE_ONE_SHOT);
  596
  597		waitingForTimer = true;
  598		},
  599
  600		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  601		// jsd Hooks
  602
  603		onBreak: function(frame, type, rv)
  604		{
  605		var debuggr = this.findDebugger(frame);
  606		if (debuggr)
  607		return this.breakIntoDebugger(debuggr, frame);
  608		else
  609		return RETURN_CONTINUE;
  610		},
  611
  612		onDebugger: function(frame, type, rv)
  613		{
  614		if (haltDebugger)
  615		{
  616		var debuggr = haltDebugger;
  617		haltDebugger = null;
  618
  619		return debuggr.onHalt(frame);
  620		}
  621		else
  622		return this.onBreak(frame, type, rv);
  623		},
  624
  625		onDebug: function(frame, type, rv)
  626		{
  627		var debuggr = reportNextError || breakOnNextError ? this.findDebugger(frame) : null;
  628
  629		if (reportNextError)
  630		{
  631		reportNextError = false;
  632		if (debuggr)
  633		debuggr.onError(frame);
  634		}
  635
  636		if (breakOnNextError)
  637		{
  638		breakOnNextError = false;
  639		if (debuggr)
  640		return this.breakIntoDebugger(debuggr, frame);
  641		}
  642
  643		return RETURN_CONTINUE;
  644		},
  645
  646		onBreakpoint: function(frame, type, val)
  647		{
  648		if (disabledCount || monitorCount || conditionCount || runningUntil)
  649		{
  650		var url = frame.script.fileName;
  651		var bp = this.findBreakpoint(url, frame.line);
  652		if (bp)
  653		{
  654		if (bp.type & BP_MONITOR && !(bp.disabled & BP_MONITOR))
  655		bp.debuggr.onCall(frame);
  656
  657		if (bp.type & BP_UNTIL)
  658		{
  659		this.stopStepping();
  660		return this.onBreak(frame, type, val);
  661		}
  662		else if (bp.type & BP_NORMAL && bp.condition)
  663		{
  664		var passed = evaluateCondition(frame, bp.condition);
  665		if (!passed)
  666		return RETURN_CONTINUE;
  667		}
  668		else if (!(bp.type & BP_NORMAL) || bp.disabled & BP_NORMAL)
  669		return RETURN_CONTINUE;
  670		}
  671		else
  672		return RETURN_CONTINUE;
  673		}
  674
  675		if (runningUntil)
  676		return RETURN_CONTINUE;
  677		else
  678		return this.onBreak(frame, type, val);
  679		},
  680
  681		onThrow: function(frame, type, val)
  682		{
  683		// Remember the error where the last exception is thrown - this will
  684		// be used later when the console service reports the error, since
  685		// it doesn't currently report the window where the error occured
  686		this._lastErrorWindow = getFrameWindow(frame);
  687
  688		return RETURN_CONTINUE_THROW;
  689		},
  690
  691		onError: function(message, fileName, lineNo, pos, flags, errnum, exc)
  692		{
  693		if (this.showStackTrace)
  694		{
  695		reportNextError = true;
  696		this.needToBreakForError(fileName, lineNo);
  697		return false;
  698		}
  699		else
  700		{
  701		return !this.needToBreakForError(fileName, lineNo);
  702		}
  703		},
  704
  705		onScriptCreated: function(script)
  706		{
  707		var url = script.fileName;
  708		if (!(url in scriptMap))
  709		scriptMap[url] = [script];
  710		else
  711		scriptMap[url].push(script);
  712
  713		// If the new script is replacing an old script with a breakpoint still
  714		// set in it, try to re-set the breakpoint in the new script
  715		var urlBreakpoints = breakpoints[url];
  716		if (urlBreakpoints)
  717		{
  718		for (var i = 0; i < urlBreakpoints.length; ++i)
  719		{
  720		var bp = urlBreakpoints[i];
  721		var lineNo = bp.lineNo;
  722		if (lineNo >= script.baseLineNumber
  723		&& lineNo <= script.baseLineNumber+script.lineExtent)
  724		{
  725		if (script.isLineExecutable(lineNo, PCMAP_SOURCETEXT))
  726		{
  727		var pc = script.lineToPc(lineNo, PCMAP_SOURCETEXT);
  728		script.setBreakpoint(pc);
  729
  730		bp.startLineNo = script.baseLineNumber;
  731		}
  732		}
  733		}
  734		}
  735		},
  736
  737		onScriptDestroyed: function(script)
  738		{
  739		var url = script.fileName;
  740		if (url in scriptMap)
  741		remove(scriptMap[url], script);
  742		},
  743
  744		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  745
  746		findDebugger: function(frame)
  747		{
  748		var win = getFrameWindow(frame);
  749		if (!win)
  750		return;
  751
  752		for (var i = 0; i < debuggers.length; ++i)
  753		{
  754		try
  755		{
  756		var debuggr = debuggers[i];
  757		if (debuggr.supportsWindow(win))
  758		return debuggr;
  759		}
  760		catch (exc) {}
  761		}
  762		},
  763
  764		findScripts: function(url, lineNo)
  765		{
  766		var hits = [];
  767
  768		var scripts = scriptMap[url];
  769		if (scripts)
  770		{
  771		for (var i = 0; i < scripts.length; ++i)
  772		{
  773		var script = scripts[i];
  774		if (lineNo >= script.baseLineNumber
  775		&& lineNo <= script.baseLineNumber+script.lineExtent
  776		&& (script.isLineExecutable(lineNo, PCMAP_SOURCETEXT)
  777		|| script.baseLineNumber == lineNo))
  778		{
  779		hits.push(script);
  780		}
  781		}
  782		}
  783
  784		return hits;
  785		},
  786
  787		findBreakpoint: function(url, lineNo)
  788		{
  789		var urlBreakpoints = breakpoints[url];
  790		if (urlBreakpoints)
  791		{
  792		for (var i = 0; i < urlBreakpoints.length; ++i)
  793		{
  794		var bp = urlBreakpoints[i];
  795		if (bp.lineNo == lineNo)
  796		return bp;
  797		}
  798		}
  799
  800		return null;
  801		},
  802
  803		findErrorBreakpoint: function(url, lineNo)
  804		{
  805		url = normalizeURL(url);
  806
  807		for (var i = 0; i < errorBreakpoints.length; ++i)
  808		{
  809		var bp = errorBreakpoints[i];
  810		if (bp.lineNo == lineNo && bp.href == url)
  811		return i;
  812		}
  813
  814		return -1;
  815		},
  816
  817		// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  818
  819		addBreakpoint: function(type, url, lineNo, debuggr, script)
  820		{
  821		url = denormalizeURL(url);
  822
  823		var bp = this.findBreakpoint(url, lineNo);
  824		if (bp && bp.type & type)
  825		return null;
  826
  827		if (bp)
  828		{
  829		bp.type |= type;
  830
  831		if (debuggr)
  832		bp.debuggr = debuggr;
  833		}
  834		else
  835		{
  836		var scripts = script ? [script] : this.findScripts(url, lineNo);
  837		for (var i = 0; i < scripts.length; ++i)
  838		{
  839		var script = scripts[i];
  840		var pc = script.lineToPc(lineNo, PCMAP_SOURCETEXT);
  841		script.setBreakpoint(pc);
  842		}
  843
  844		var urlBreakpoints = breakpoints[url];
  845		if (!urlBreakpoints)
  846		breakpoints[url] = urlBreakpoints = [];
  847
  848		bp = {type: type, href: url, lineNo: lineNo, disabled: 0,
  849		startLineNo: scripts.length ? scripts[0].baseLineNumber : -1, debuggr: debuggr,
  850