eric: comparison DebugClients/Python/DebugBase.py

-:82e91d2f59a1
+:e2fa12bb0f53
 #  on Windows
 lib = os.path.dirname(bdb.__file__)
 # tuple required because it's accessed a lot of times by startswith method
 pathsToSkip = ('<', os.path.dirname(__file__), bdb.__file__[:-1])
 filesToSkip = {}
+# cache for fixed file names
+_fnCache = {}
 def __init__(self, dbgClient):
 """
 Constructor
 this can break debugging as the .pyc will refer to the .py
 on the original machine. Another case might be sharing
 code over a network... This logic deals with that.
 @param frame the frame object
-@return fixed up file name (string)
+@type frame object
+@return fixed up file name
+@rtype str
 """
 # get module name from __file__
-if '__file__' in frame.f_globals and \
+fn = frame.f_globals.get('__file__')
-frame.f_globals['__file__'] and \
+try:
-frame.f_globals['__file__'] == frame.f_code.co_filename:
+return self._fnCache[fn]
-root, ext = os.path.splitext(frame.f_globals['__file__'])
+except KeyError:
-if ext == '.pyc' or ext == '.py' or ext == '.pyo':
+if fn and fn != frame.f_code.co_filename:
-fixedName = root + '.py'
+absFilename = os.path.abspath(fn)
-if os.path.exists(fixedName):
+if absFilename.endswith(('.pyc', '.pyo')):
-return fixedName
+fixedName = absFilename[:-1]
+if not os.path.exists(fixedName):
-return frame.f_code.co_filename
+fixedName = absFilename
+else:
+fixedName = absFilename
+else:
+fixedName = frame.f_code.co_filename
+# update cache
+self._fnCache[fn] = fixedName
+return fixedName
 def set_watch(self, cond, temporary=0):
 """
 Public method to set a watch expression.
 See fix_frame_filename for more info.
 @param frame the frame object
 @return flag indicating the break status (boolean)
 """
-filename = self.canonic(self.fix_frame_filename(frame))
+filename = self.fix_frame_filename(frame)
 if filename not in self.breaks and "Watch" not in self.breaks:
 return 0
 if filename in self.breaks:
 lineno = frame.f_lineno
 @param frame the frame object
 @return flag indicating the break status (boolean)
 """
 return \
-self.canonic(self.fix_frame_filename(frame)) in self.breaks or \
+self.fix_frame_filename(frame) in self.breaks or \
 ("Watch" in self.breaks and self.breaks["Watch"])
+def set_break(self, filename, lineno, temporary=0, cond=None,
+funcname=None):
+"""
+Public method reimplemented from bdb.py to normalize the filename and
+set as a breakpoint.
+@param filename the filename where a breakpoint is set
+@type str
+@param lineno the line number of the breakpoint
+@type int
+@keyparam temporary flag to indicate a temporary breakpoint
+@type int
+@keyparam cond Python expression which dynamically enables this bp
+@type str
+@keyparam funcname name of the function (unused)
+@type str or None
+"""
+filename = os.path.abspath(filename)
+list = self.breaks.setdefault(filename, [])
+if lineno not in list:
+list.append(lineno)
+bdb.Breakpoint(filename, lineno, temporary, cond, funcname)
 def get_break(self, filename, lineno):
 """
 Public method reimplemented from bdb.py to get the first breakpoint of
 a particular line.
 Because eric6 supports only one breakpoint per line, this overwritten
 method will return this one and only breakpoint.
-@param filename the filename of the bp to retrieve (string)
+@param filename the filename of the bp to retrieve
-@param lineno the linenumber of the bp to retrieve (integer)
+@type str
+@param lineno the linenumber of the bp to retrieve
+@type int
 @return breakpoint or None, if there is no bp
-"""
+@rtype breakpoint object or None
-filename = self.canonic(filename)
+"""
-return filename in self.breaks and \
+return (lineno in self.breaks.get(filename, []) and
-lineno in self.breaks[filename] and \
+bdb.Breakpoint.bplist[filename, lineno][0] or None)
-bdb.Breakpoint.bplist[filename, lineno][0] or None
+def clear_break(self, filename, lineno):
+"""
+Public method reimplemented from bdb.py to clear a breakpoint.
+@param filename the filename of the bp to retrieve
+@type str
+@param lineno the linenumber of the bp to retrieve
+@type int
+"""
+if (filename, lineno) not in bdb.Breakpoint.bplist:
+return
+# If there's only one bp in the list for that file,line
+# pair, then remove the breaks entry
+for bp in bdb.Breakpoint.bplist[filename, lineno][:]:
+bp.deleteMe()
+self._prune_breaks(filename, lineno)
 def __do_clear(self, filename, lineno):
 """
 Private method called to clear a temporary breakpoint.
 @param filename name of the file the bp belongs to
 return 0
 return bdb.Bdb.stop_here(self, frame)
 def tracePythonLibs(self, enable):
 """
-Public methode to update the settings to trace into Python libraries.
+Public method to update the settings to trace into Python libraries.
-@param enable let's debug into Python libraries (int)
+@param enable flag to debug into Python libraries
+@type int
 """
 pathsToSkip = list(self.pathsToSkip)
 # don't trace into Python library?
 if enable:
 pathsToSkip = [x for x in pathsToSkip if not x.endswith(
 Tracing is turned off for files that are part of the
 debugger that are called from the application being debugged.
 @param frame the frame object
+@type frame object
 @return flag indicating whether the debugger should skip this frame
+@rtype bool
 """
 try:
 return self.filesToSkip[frame.f_code.co_filename]
 except KeyError:
 ret = frame.f_code.co_filename.startswith(self.pathsToSkip)

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/DebugBase.py

DebugClients/Python/DebugBase.py