• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#! /usr/bin/env python
2
3"""A Python debugger."""
4
5# (See pdb.doc for documentation.)
6
7import sys
8import linecache
9import cmd
10import bdb
11from repr import Repr
12import os
13import re
14import pprint
15import traceback
16
17
18class Restart(Exception):
19    """Causes a debugger to be restarted for the debugged python program."""
20    pass
21
22# Create a custom safe Repr instance and increase its maxstring.
23# The default of 30 truncates error messages too easily.
24_repr = Repr()
25_repr.maxstring = 200
26_saferepr = _repr.repr
27
28__all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace",
29           "post_mortem", "help"]
30
31def find_function(funcname, filename):
32    cre = re.compile(r'def\s+%s\s*[(]' % re.escape(funcname))
33    try:
34        fp = open(filename)
35    except IOError:
36        return None
37    # consumer of this info expects the first line to be 1
38    lineno = 1
39    answer = None
40    while 1:
41        line = fp.readline()
42        if line == '':
43            break
44        if cre.match(line):
45            answer = funcname, filename, lineno
46            break
47        lineno = lineno + 1
48    fp.close()
49    return answer
50
51
52# Interaction prompt line will separate file and call info from code
53# text using value of line_prefix string.  A newline and arrow may
54# be to your liking.  You can set it once pdb is imported using the
55# command "pdb.line_prefix = '\n% '".
56# line_prefix = ': '    # Use this to get the old situation back
57line_prefix = '\n-> '   # Probably a better default
58
59class Pdb(bdb.Bdb, cmd.Cmd):
60
61    def __init__(self, completekey='tab', stdin=None, stdout=None, skip=None):
62        bdb.Bdb.__init__(self, skip=skip)
63        cmd.Cmd.__init__(self, completekey, stdin, stdout)
64        if stdout:
65            self.use_rawinput = 0
66        self.prompt = '(Pdb) '
67        self.aliases = {}
68        self.mainpyfile = ''
69        self._wait_for_mainpyfile = 0
70        # Try to load readline if it exists
71        try:
72            import readline
73        except ImportError:
74            pass
75
76        # Read $HOME/.pdbrc and ./.pdbrc
77        self.rcLines = []
78        if 'HOME' in os.environ:
79            envHome = os.environ['HOME']
80            try:
81                rcFile = open(os.path.join(envHome, ".pdbrc"))
82            except IOError:
83                pass
84            else:
85                for line in rcFile.readlines():
86                    self.rcLines.append(line)
87                rcFile.close()
88        try:
89            rcFile = open(".pdbrc")
90        except IOError:
91            pass
92        else:
93            for line in rcFile.readlines():
94                self.rcLines.append(line)
95            rcFile.close()
96
97        self.commands = {} # associates a command list to breakpoint numbers
98        self.commands_doprompt = {} # for each bp num, tells if the prompt
99                                    # must be disp. after execing the cmd list
100        self.commands_silent = {} # for each bp num, tells if the stack trace
101                                  # must be disp. after execing the cmd list
102        self.commands_defining = False # True while in the process of defining
103                                       # a command list
104        self.commands_bnum = None # The breakpoint number for which we are
105                                  # defining a list
106
107    def reset(self):
108        bdb.Bdb.reset(self)
109        self.forget()
110
111    def forget(self):
112        self.lineno = None
113        self.stack = []
114        self.curindex = 0
115        self.curframe = None
116
117    def setup(self, f, t):
118        self.forget()
119        self.stack, self.curindex = self.get_stack(f, t)
120        self.curframe = self.stack[self.curindex][0]
121        # The f_locals dictionary is updated from the actual frame
122        # locals whenever the .f_locals accessor is called, so we
123        # cache it here to ensure that modifications are not overwritten.
124        self.curframe_locals = self.curframe.f_locals
125        self.execRcLines()
126
127    # Can be executed earlier than 'setup' if desired
128    def execRcLines(self):
129        if self.rcLines:
130            # Make local copy because of recursion
131            rcLines = self.rcLines
132            # executed only once
133            self.rcLines = []
134            for line in rcLines:
135                line = line[:-1]
136                if len(line) > 0 and line[0] != '#':
137                    self.onecmd(line)
138
139    # Override Bdb methods
140
141    def user_call(self, frame, argument_list):
142        """This method is called when there is the remote possibility
143        that we ever need to stop in this function."""
144        if self._wait_for_mainpyfile:
145            return
146        if self.stop_here(frame):
147            print >>self.stdout, '--Call--'
148            self.interaction(frame, None)
149
150    def user_line(self, frame):
151        """This function is called when we stop or break at this line."""
152        if self._wait_for_mainpyfile:
153            if (self.mainpyfile != self.canonic(frame.f_code.co_filename)
154                or frame.f_lineno<= 0):
155                return
156            self._wait_for_mainpyfile = 0
157        if self.bp_commands(frame):
158            self.interaction(frame, None)
159
160    def bp_commands(self,frame):
161        """Call every command that was set for the current active breakpoint
162        (if there is one).
163
164        Returns True if the normal interaction function must be called,
165        False otherwise."""
166        # self.currentbp is set in bdb in Bdb.break_here if a breakpoint was hit
167        if getattr(self, "currentbp", False) and \
168               self.currentbp in self.commands:
169            currentbp = self.currentbp
170            self.currentbp = 0
171            lastcmd_back = self.lastcmd
172            self.setup(frame, None)
173            for line in self.commands[currentbp]:
174                self.onecmd(line)
175            self.lastcmd = lastcmd_back
176            if not self.commands_silent[currentbp]:
177                self.print_stack_entry(self.stack[self.curindex])
178            if self.commands_doprompt[currentbp]:
179                self.cmdloop()
180            self.forget()
181            return
182        return 1
183
184    def user_return(self, frame, return_value):
185        """This function is called when a return trap is set here."""
186        if self._wait_for_mainpyfile:
187            return
188        frame.f_locals['__return__'] = return_value
189        print >>self.stdout, '--Return--'
190        self.interaction(frame, None)
191
192    def user_exception(self, frame, exc_info):
193        """This function is called if an exception occurs,
194        but only if we are to stop at or just below this level."""
195        if self._wait_for_mainpyfile:
196            return
197        exc_type, exc_value, exc_traceback = exc_info
198        frame.f_locals['__exception__'] = exc_type, exc_value
199        if type(exc_type) == type(''):
200            exc_type_name = exc_type
201        else: exc_type_name = exc_type.__name__
202        print >>self.stdout, exc_type_name + ':', _saferepr(exc_value)
203        self.interaction(frame, exc_traceback)
204
205    # General interaction function
206
207    def interaction(self, frame, traceback):
208        self.setup(frame, traceback)
209        self.print_stack_entry(self.stack[self.curindex])
210        self.cmdloop()
211        self.forget()
212
213    def displayhook(self, obj):
214        """Custom displayhook for the exec in default(), which prevents
215        assignment of the _ variable in the builtins.
216        """
217        # reproduce the behavior of the standard displayhook, not printing None
218        if obj is not None:
219            print repr(obj)
220
221    def default(self, line):
222        if line[:1] == '!': line = line[1:]
223        locals = self.curframe_locals
224        globals = self.curframe.f_globals
225        try:
226            code = compile(line + '\n', '<stdin>', 'single')
227            save_stdout = sys.stdout
228            save_stdin = sys.stdin
229            save_displayhook = sys.displayhook
230            try:
231                sys.stdin = self.stdin
232                sys.stdout = self.stdout
233                sys.displayhook = self.displayhook
234                exec code in globals, locals
235            finally:
236                sys.stdout = save_stdout
237                sys.stdin = save_stdin
238                sys.displayhook = save_displayhook
239        except:
240            t, v = sys.exc_info()[:2]
241            if type(t) == type(''):
242                exc_type_name = t
243            else: exc_type_name = t.__name__
244            print >>self.stdout, '***', exc_type_name + ':', v
245
246    def precmd(self, line):
247        """Handle alias expansion and ';;' separator."""
248        if not line.strip():
249            return line
250        args = line.split()
251        while args[0] in self.aliases:
252            line = self.aliases[args[0]]
253            ii = 1
254            for tmpArg in args[1:]:
255                line = line.replace("%" + str(ii),
256                                      tmpArg)
257                ii = ii + 1
258            line = line.replace("%*", ' '.join(args[1:]))
259            args = line.split()
260        # split into ';;' separated commands
261        # unless it's an alias command
262        if args[0] != 'alias':
263            marker = line.find(';;')
264            if marker >= 0:
265                # queue up everything after marker
266                next = line[marker+2:].lstrip()
267                self.cmdqueue.append(next)
268                line = line[:marker].rstrip()
269        return line
270
271    def onecmd(self, line):
272        """Interpret the argument as though it had been typed in response
273        to the prompt.
274
275        Checks whether this line is typed at the normal prompt or in
276        a breakpoint command list definition.
277        """
278        if not self.commands_defining:
279            return cmd.Cmd.onecmd(self, line)
280        else:
281            return self.handle_command_def(line)
282
283    def handle_command_def(self,line):
284        """Handles one command line during command list definition."""
285        cmd, arg, line = self.parseline(line)
286        if not cmd:
287            return
288        if cmd == 'silent':
289            self.commands_silent[self.commands_bnum] = True
290            return # continue to handle other cmd def in the cmd list
291        elif cmd == 'end':
292            self.cmdqueue = []
293            return 1 # end of cmd list
294        cmdlist = self.commands[self.commands_bnum]
295        if arg:
296            cmdlist.append(cmd+' '+arg)
297        else:
298            cmdlist.append(cmd)
299        # Determine if we must stop
300        try:
301            func = getattr(self, 'do_' + cmd)
302        except AttributeError:
303            func = self.default
304        # one of the resuming commands
305        if func.func_name in self.commands_resuming:
306            self.commands_doprompt[self.commands_bnum] = False
307            self.cmdqueue = []
308            return 1
309        return
310
311    # Command definitions, called by cmdloop()
312    # The argument is the remaining string on the command line
313    # Return true to exit from the command loop
314
315    do_h = cmd.Cmd.do_help
316
317    def do_commands(self, arg):
318        """Defines a list of commands associated to a breakpoint.
319
320        Those commands will be executed whenever the breakpoint causes
321        the program to stop execution."""
322        if not arg:
323            bnum = len(bdb.Breakpoint.bpbynumber)-1
324        else:
325            try:
326                bnum = int(arg)
327            except:
328                print >>self.stdout, "Usage : commands [bnum]\n        ..." \
329                                     "\n        end"
330                return
331        self.commands_bnum = bnum
332        self.commands[bnum] = []
333        self.commands_doprompt[bnum] = True
334        self.commands_silent[bnum] = False
335        prompt_back = self.prompt
336        self.prompt = '(com) '
337        self.commands_defining = True
338        try:
339            self.cmdloop()
340        finally:
341            self.commands_defining = False
342            self.prompt = prompt_back
343
344    def do_break(self, arg, temporary = 0):
345        # break [ ([filename:]lineno | function) [, "condition"] ]
346        if not arg:
347            if self.breaks:  # There's at least one
348                print >>self.stdout, "Num Type         Disp Enb   Where"
349                for bp in bdb.Breakpoint.bpbynumber:
350                    if bp:
351                        bp.bpprint(self.stdout)
352            return
353        # parse arguments; comma has lowest precedence
354        # and cannot occur in filename
355        filename = None
356        lineno = None
357        cond = None
358        comma = arg.find(',')
359        if comma > 0:
360            # parse stuff after comma: "condition"
361            cond = arg[comma+1:].lstrip()
362            arg = arg[:comma].rstrip()
363        # parse stuff before comma: [filename:]lineno | function
364        colon = arg.rfind(':')
365        funcname = None
366        if colon >= 0:
367            filename = arg[:colon].rstrip()
368            f = self.lookupmodule(filename)
369            if not f:
370                print >>self.stdout, '*** ', repr(filename),
371                print >>self.stdout, 'not found from sys.path'
372                return
373            else:
374                filename = f
375            arg = arg[colon+1:].lstrip()
376            try:
377                lineno = int(arg)
378            except ValueError, msg:
379                print >>self.stdout, '*** Bad lineno:', arg
380                return
381        else:
382            # no colon; can be lineno or function
383            try:
384                lineno = int(arg)
385            except ValueError:
386                try:
387                    func = eval(arg,
388                                self.curframe.f_globals,
389                                self.curframe_locals)
390                except:
391                    func = arg
392                try:
393                    if hasattr(func, 'im_func'):
394                        func = func.im_func
395                    code = func.func_code
396                    #use co_name to identify the bkpt (function names
397                    #could be aliased, but co_name is invariant)
398                    funcname = code.co_name
399                    lineno = code.co_firstlineno
400                    filename = code.co_filename
401                except:
402                    # last thing to try
403                    (ok, filename, ln) = self.lineinfo(arg)
404                    if not ok:
405                        print >>self.stdout, '*** The specified object',
406                        print >>self.stdout, repr(arg),
407                        print >>self.stdout, 'is not a function'
408                        print >>self.stdout, 'or was not found along sys.path.'
409                        return
410                    funcname = ok # ok contains a function name
411                    lineno = int(ln)
412        if not filename:
413            filename = self.defaultFile()
414        # Check for reasonable breakpoint
415        line = self.checkline(filename, lineno)
416        if line:
417            # now set the break point
418            err = self.set_break(filename, line, temporary, cond, funcname)
419            if err: print >>self.stdout, '***', err
420            else:
421                bp = self.get_breaks(filename, line)[-1]
422                print >>self.stdout, "Breakpoint %d at %s:%d" % (bp.number,
423                                                                 bp.file,
424                                                                 bp.line)
425
426    # To be overridden in derived debuggers
427    def defaultFile(self):
428        """Produce a reasonable default."""
429        filename = self.curframe.f_code.co_filename
430        if filename == '<string>' and self.mainpyfile:
431            filename = self.mainpyfile
432        return filename
433
434    do_b = do_break
435
436    def do_tbreak(self, arg):
437        self.do_break(arg, 1)
438
439    def lineinfo(self, identifier):
440        failed = (None, None, None)
441        # Input is identifier, may be in single quotes
442        idstring = identifier.split("'")
443        if len(idstring) == 1:
444            # not in single quotes
445            id = idstring[0].strip()
446        elif len(idstring) == 3:
447            # quoted
448            id = idstring[1].strip()
449        else:
450            return failed
451        if id == '': return failed
452        parts = id.split('.')
453        # Protection for derived debuggers
454        if parts[0] == 'self':
455            del parts[0]
456            if len(parts) == 0:
457                return failed
458        # Best first guess at file to look at
459        fname = self.defaultFile()
460        if len(parts) == 1:
461            item = parts[0]
462        else:
463            # More than one part.
464            # First is module, second is method/class
465            f = self.lookupmodule(parts[0])
466            if f:
467                fname = f
468            item = parts[1]
469        answer = find_function(item, fname)
470        return answer or failed
471
472    def checkline(self, filename, lineno):
473        """Check whether specified line seems to be executable.
474
475        Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
476        line or EOF). Warning: testing is not comprehensive.
477        """
478        # this method should be callable before starting debugging, so default
479        # to "no globals" if there is no current frame
480        globs = self.curframe.f_globals if hasattr(self, 'curframe') else None
481        line = linecache.getline(filename, lineno, globs)
482        if not line:
483            print >>self.stdout, 'End of file'
484            return 0
485        line = line.strip()
486        # Don't allow setting breakpoint at a blank line
487        if (not line or (line[0] == '#') or
488             (line[:3] == '"""') or line[:3] == "'''"):
489            print >>self.stdout, '*** Blank or comment'
490            return 0
491        return lineno
492
493    def do_enable(self, arg):
494        args = arg.split()
495        for i in args:
496            try:
497                i = int(i)
498            except ValueError:
499                print >>self.stdout, 'Breakpoint index %r is not a number' % i
500                continue
501
502            if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
503                print >>self.stdout, 'No breakpoint numbered', i
504                continue
505
506            bp = bdb.Breakpoint.bpbynumber[i]
507            if bp:
508                bp.enable()
509
510    def do_disable(self, arg):
511        args = arg.split()
512        for i in args:
513            try:
514                i = int(i)
515            except ValueError:
516                print >>self.stdout, 'Breakpoint index %r is not a number' % i
517                continue
518
519            if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
520                print >>self.stdout, 'No breakpoint numbered', i
521                continue
522
523            bp = bdb.Breakpoint.bpbynumber[i]
524            if bp:
525                bp.disable()
526
527    def do_condition(self, arg):
528        # arg is breakpoint number and condition
529        args = arg.split(' ', 1)
530        try:
531            bpnum = int(args[0].strip())
532        except ValueError:
533            # something went wrong
534            print >>self.stdout, \
535                'Breakpoint index %r is not a number' % args[0]
536            return
537        try:
538            cond = args[1]
539        except:
540            cond = None
541        try:
542            bp = bdb.Breakpoint.bpbynumber[bpnum]
543        except IndexError:
544            print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]
545            return
546        if bp:
547            bp.cond = cond
548            if not cond:
549                print >>self.stdout, 'Breakpoint', bpnum,
550                print >>self.stdout, 'is now unconditional.'
551
552    def do_ignore(self,arg):
553        """arg is bp number followed by ignore count."""
554        args = arg.split()
555        try:
556            bpnum = int(args[0].strip())
557        except ValueError:
558            # something went wrong
559            print >>self.stdout, \
560                'Breakpoint index %r is not a number' % args[0]
561            return
562        try:
563            count = int(args[1].strip())
564        except:
565            count = 0
566        try:
567            bp = bdb.Breakpoint.bpbynumber[bpnum]
568        except IndexError:
569            print >>self.stdout, 'Breakpoint index %r is not valid' % args[0]
570            return
571        if bp:
572            bp.ignore = count
573            if count > 0:
574                reply = 'Will ignore next '
575                if count > 1:
576                    reply = reply + '%d crossings' % count
577                else:
578                    reply = reply + '1 crossing'
579                print >>self.stdout, reply + ' of breakpoint %d.' % bpnum
580            else:
581                print >>self.stdout, 'Will stop next time breakpoint',
582                print >>self.stdout, bpnum, 'is reached.'
583
584    def do_clear(self, arg):
585        """Three possibilities, tried in this order:
586        clear -> clear all breaks, ask for confirmation
587        clear file:lineno -> clear all breaks at file:lineno
588        clear bpno bpno ... -> clear breakpoints by number"""
589        if not arg:
590            try:
591                reply = raw_input('Clear all breaks? ')
592            except EOFError:
593                reply = 'no'
594            reply = reply.strip().lower()
595            if reply in ('y', 'yes'):
596                self.clear_all_breaks()
597            return
598        if ':' in arg:
599            # Make sure it works for "clear C:\foo\bar.py:12"
600            i = arg.rfind(':')
601            filename = arg[:i]
602            arg = arg[i+1:]
603            try:
604                lineno = int(arg)
605            except ValueError:
606                err = "Invalid line number (%s)" % arg
607            else:
608                err = self.clear_break(filename, lineno)
609            if err: print >>self.stdout, '***', err
610            return
611        numberlist = arg.split()
612        for i in numberlist:
613            try:
614                i = int(i)
615            except ValueError:
616                print >>self.stdout, 'Breakpoint index %r is not a number' % i
617                continue
618
619            if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):
620                print >>self.stdout, 'No breakpoint numbered', i
621                continue
622            err = self.clear_bpbynumber(i)
623            if err:
624                print >>self.stdout, '***', err
625            else:
626                print >>self.stdout, 'Deleted breakpoint', i
627    do_cl = do_clear # 'c' is already an abbreviation for 'continue'
628
629    def do_where(self, arg):
630        self.print_stack_trace()
631    do_w = do_where
632    do_bt = do_where
633
634    def do_up(self, arg):
635        if self.curindex == 0:
636            print >>self.stdout, '*** Oldest frame'
637        else:
638            self.curindex = self.curindex - 1
639            self.curframe = self.stack[self.curindex][0]
640            self.curframe_locals = self.curframe.f_locals
641            self.print_stack_entry(self.stack[self.curindex])
642            self.lineno = None
643    do_u = do_up
644
645    def do_down(self, arg):
646        if self.curindex + 1 == len(self.stack):
647            print >>self.stdout, '*** Newest frame'
648        else:
649            self.curindex = self.curindex + 1
650            self.curframe = self.stack[self.curindex][0]
651            self.curframe_locals = self.curframe.f_locals
652            self.print_stack_entry(self.stack[self.curindex])
653            self.lineno = None
654    do_d = do_down
655
656    def do_until(self, arg):
657        self.set_until(self.curframe)
658        return 1
659    do_unt = do_until
660
661    def do_step(self, arg):
662        self.set_step()
663        return 1
664    do_s = do_step
665
666    def do_next(self, arg):
667        self.set_next(self.curframe)
668        return 1
669    do_n = do_next
670
671    def do_run(self, arg):
672        """Restart program by raising an exception to be caught in the main
673        debugger loop.  If arguments were given, set them in sys.argv."""
674        if arg:
675            import shlex
676            argv0 = sys.argv[0:1]
677            sys.argv = shlex.split(arg)
678            sys.argv[:0] = argv0
679        raise Restart
680
681    do_restart = do_run
682
683    def do_return(self, arg):
684        self.set_return(self.curframe)
685        return 1
686    do_r = do_return
687
688    def do_continue(self, arg):
689        self.set_continue()
690        return 1
691    do_c = do_cont = do_continue
692
693    def do_jump(self, arg):
694        if self.curindex + 1 != len(self.stack):
695            print >>self.stdout, "*** You can only jump within the bottom frame"
696            return
697        try:
698            arg = int(arg)
699        except ValueError:
700            print >>self.stdout, "*** The 'jump' command requires a line number."
701        else:
702            try:
703                # Do the jump, fix up our copy of the stack, and display the
704                # new position
705                self.curframe.f_lineno = arg
706                self.stack[self.curindex] = self.stack[self.curindex][0], arg
707                self.print_stack_entry(self.stack[self.curindex])
708            except ValueError, e:
709                print >>self.stdout, '*** Jump failed:', e
710    do_j = do_jump
711
712    def do_debug(self, arg):
713        sys.settrace(None)
714        globals = self.curframe.f_globals
715        locals = self.curframe_locals
716        p = Pdb(self.completekey, self.stdin, self.stdout)
717        p.prompt = "(%s) " % self.prompt.strip()
718        print >>self.stdout, "ENTERING RECURSIVE DEBUGGER"
719        sys.call_tracing(p.run, (arg, globals, locals))
720        print >>self.stdout, "LEAVING RECURSIVE DEBUGGER"
721        sys.settrace(self.trace_dispatch)
722        self.lastcmd = p.lastcmd
723
724    def do_quit(self, arg):
725        self._user_requested_quit = 1
726        self.set_quit()
727        return 1
728
729    do_q = do_quit
730    do_exit = do_quit
731
732    def do_EOF(self, arg):
733        print >>self.stdout
734        self._user_requested_quit = 1
735        self.set_quit()
736        return 1
737
738    def do_args(self, arg):
739        co = self.curframe.f_code
740        dict = self.curframe_locals
741        n = co.co_argcount
742        if co.co_flags & 4: n = n+1
743        if co.co_flags & 8: n = n+1
744        for i in range(n):
745            name = co.co_varnames[i]
746            print >>self.stdout, name, '=',
747            if name in dict: print >>self.stdout, dict[name]
748            else: print >>self.stdout, "*** undefined ***"
749    do_a = do_args
750
751    def do_retval(self, arg):
752        if '__return__' in self.curframe_locals:
753            print >>self.stdout, self.curframe_locals['__return__']
754        else:
755            print >>self.stdout, '*** Not yet returned!'
756    do_rv = do_retval
757
758    def _getval(self, arg):
759        try:
760            return eval(arg, self.curframe.f_globals,
761                        self.curframe_locals)
762        except:
763            t, v = sys.exc_info()[:2]
764            if isinstance(t, str):
765                exc_type_name = t
766            else: exc_type_name = t.__name__
767            print >>self.stdout, '***', exc_type_name + ':', repr(v)
768            raise
769
770    def do_p(self, arg):
771        try:
772            print >>self.stdout, repr(self._getval(arg))
773        except:
774            pass
775
776    def do_pp(self, arg):
777        try:
778            pprint.pprint(self._getval(arg), self.stdout)
779        except:
780            pass
781
782    def do_list(self, arg):
783        self.lastcmd = 'list'
784        last = None
785        if arg:
786            try:
787                x = eval(arg, {}, {})
788                if type(x) == type(()):
789                    first, last = x
790                    first = int(first)
791                    last = int(last)
792                    if last < first:
793                        # Assume it's a count
794                        last = first + last
795                else:
796                    first = max(1, int(x) - 5)
797            except:
798                print >>self.stdout, '*** Error in argument:', repr(arg)
799                return
800        elif self.lineno is None:
801            first = max(1, self.curframe.f_lineno - 5)
802        else:
803            first = self.lineno + 1
804        if last is None:
805            last = first + 10
806        filename = self.curframe.f_code.co_filename
807        breaklist = self.get_file_breaks(filename)
808        try:
809            for lineno in range(first, last+1):
810                line = linecache.getline(filename, lineno,
811                                         self.curframe.f_globals)
812                if not line:
813                    print >>self.stdout, '[EOF]'
814                    break
815                else:
816                    s = repr(lineno).rjust(3)
817                    if len(s) < 4: s = s + ' '
818                    if lineno in breaklist: s = s + 'B'
819                    else: s = s + ' '
820                    if lineno == self.curframe.f_lineno:
821                        s = s + '->'
822                    print >>self.stdout, s + '\t' + line,
823                    self.lineno = lineno
824        except KeyboardInterrupt:
825            pass
826    do_l = do_list
827
828    def do_whatis(self, arg):
829        try:
830            value = eval(arg, self.curframe.f_globals,
831                            self.curframe_locals)
832        except:
833            t, v = sys.exc_info()[:2]
834            if type(t) == type(''):
835                exc_type_name = t
836            else: exc_type_name = t.__name__
837            print >>self.stdout, '***', exc_type_name + ':', repr(v)
838            return
839        code = None
840        # Is it a function?
841        try: code = value.func_code
842        except: pass
843        if code:
844            print >>self.stdout, 'Function', code.co_name
845            return
846        # Is it an instance method?
847        try: code = value.im_func.func_code
848        except: pass
849        if code:
850            print >>self.stdout, 'Method', code.co_name
851            return
852        # None of the above...
853        print >>self.stdout, type(value)
854
855    def do_alias(self, arg):
856        args = arg.split()
857        if len(args) == 0:
858            keys = self.aliases.keys()
859            keys.sort()
860            for alias in keys:
861                print >>self.stdout, "%s = %s" % (alias, self.aliases[alias])
862            return
863        if args[0] in self.aliases and len(args) == 1:
864            print >>self.stdout, "%s = %s" % (args[0], self.aliases[args[0]])
865        else:
866            self.aliases[args[0]] = ' '.join(args[1:])
867
868    def do_unalias(self, arg):
869        args = arg.split()
870        if len(args) == 0: return
871        if args[0] in self.aliases:
872            del self.aliases[args[0]]
873
874    #list of all the commands making the program resume execution.
875    commands_resuming = ['do_continue', 'do_step', 'do_next', 'do_return',
876                         'do_quit', 'do_jump']
877
878    # Print a traceback starting at the top stack frame.
879    # The most recently entered frame is printed last;
880    # this is different from dbx and gdb, but consistent with
881    # the Python interpreter's stack trace.
882    # It is also consistent with the up/down commands (which are
883    # compatible with dbx and gdb: up moves towards 'main()'
884    # and down moves towards the most recent stack frame).
885
886    def print_stack_trace(self):
887        try:
888            for frame_lineno in self.stack:
889                self.print_stack_entry(frame_lineno)
890        except KeyboardInterrupt:
891            pass
892
893    def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix):
894        frame, lineno = frame_lineno
895        if frame is self.curframe:
896            print >>self.stdout, '>',
897        else:
898            print >>self.stdout, ' ',
899        print >>self.stdout, self.format_stack_entry(frame_lineno,
900                                                     prompt_prefix)
901
902
903    # Help methods (derived from pdb.doc)
904
905    def help_help(self):
906        self.help_h()
907
908    def help_h(self):
909        print >>self.stdout, """h(elp)
910Without argument, print the list of available commands.
911With a command name as argument, print help about that command
912"help pdb" pipes the full documentation file to the $PAGER
913"help exec" gives help on the ! command"""
914
915    def help_where(self):
916        self.help_w()
917
918    def help_w(self):
919        print >>self.stdout, """w(here)
920Print a stack trace, with the most recent frame at the bottom.
921An arrow indicates the "current frame", which determines the
922context of most commands.  'bt' is an alias for this command."""
923
924    help_bt = help_w
925
926    def help_down(self):
927        self.help_d()
928
929    def help_d(self):
930        print >>self.stdout, """d(own)
931Move the current frame one level down in the stack trace
932(to a newer frame)."""
933
934    def help_up(self):
935        self.help_u()
936
937    def help_u(self):
938        print >>self.stdout, """u(p)
939Move the current frame one level up in the stack trace
940(to an older frame)."""
941
942    def help_break(self):
943        self.help_b()
944
945    def help_b(self):
946        print >>self.stdout, """b(reak) ([file:]lineno | function) [, condition]
947With a line number argument, set a break there in the current
948file.  With a function name, set a break at first executable line
949of that function.  Without argument, list all breaks.  If a second
950argument is present, it is a string specifying an expression
951which must evaluate to true before the breakpoint is honored.
952
953The line number may be prefixed with a filename and a colon,
954to specify a breakpoint in another file (probably one that
955hasn't been loaded yet).  The file is searched for on sys.path;
956the .py suffix may be omitted."""
957
958    def help_clear(self):
959        self.help_cl()
960
961    def help_cl(self):
962        print >>self.stdout, "cl(ear) filename:lineno"
963        print >>self.stdout, """cl(ear) [bpnumber [bpnumber...]]
964With a space separated list of breakpoint numbers, clear
965those breakpoints.  Without argument, clear all breaks (but
966first ask confirmation).  With a filename:lineno argument,
967clear all breaks at that line in that file.
968
969Note that the argument is different from previous versions of
970the debugger (in python distributions 1.5.1 and before) where
971a linenumber was used instead of either filename:lineno or
972breakpoint numbers."""
973
974    def help_tbreak(self):
975        print >>self.stdout, """tbreak  same arguments as break, but breakpoint
976is removed when first hit."""
977
978    def help_enable(self):
979        print >>self.stdout, """enable bpnumber [bpnumber ...]
980Enables the breakpoints given as a space separated list of
981bp numbers."""
982
983    def help_disable(self):
984        print >>self.stdout, """disable bpnumber [bpnumber ...]
985Disables the breakpoints given as a space separated list of
986bp numbers."""
987
988    def help_ignore(self):
989        print >>self.stdout, """ignore bpnumber count
990Sets the ignore count for the given breakpoint number.  A breakpoint
991becomes active when the ignore count is zero.  When non-zero, the
992count is decremented each time the breakpoint is reached and the
993breakpoint is not disabled and any associated condition evaluates
994to true."""
995
996    def help_condition(self):
997        print >>self.stdout, """condition bpnumber str_condition
998str_condition is a string specifying an expression which
999must evaluate to true before the breakpoint is honored.
1000If str_condition is absent, any existing condition is removed;
1001i.e., the breakpoint is made unconditional."""
1002
1003    def help_step(self):
1004        self.help_s()
1005
1006    def help_s(self):
1007        print >>self.stdout, """s(tep)
1008Execute the current line, stop at the first possible occasion
1009(either in a function that is called or in the current function)."""
1010
1011    def help_until(self):
1012        self.help_unt()
1013
1014    def help_unt(self):
1015        print """unt(il)
1016Continue execution until the line with a number greater than the current
1017one is reached or until the current frame returns"""
1018
1019    def help_next(self):
1020        self.help_n()
1021
1022    def help_n(self):
1023        print >>self.stdout, """n(ext)
1024Continue execution until the next line in the current function
1025is reached or it returns."""
1026
1027    def help_return(self):
1028        self.help_r()
1029
1030    def help_r(self):
1031        print >>self.stdout, """r(eturn)
1032Continue execution until the current function returns."""
1033
1034    def help_continue(self):
1035        self.help_c()
1036
1037    def help_cont(self):
1038        self.help_c()
1039
1040    def help_c(self):
1041        print >>self.stdout, """c(ont(inue))
1042Continue execution, only stop when a breakpoint is encountered."""
1043
1044    def help_jump(self):
1045        self.help_j()
1046
1047    def help_j(self):
1048        print >>self.stdout, """j(ump) lineno
1049Set the next line that will be executed."""
1050
1051    def help_debug(self):
1052        print >>self.stdout, """debug code
1053Enter a recursive debugger that steps through the code argument
1054(which is an arbitrary expression or statement to be executed
1055in the current environment)."""
1056
1057    def help_list(self):
1058        self.help_l()
1059
1060    def help_l(self):
1061        print >>self.stdout, """l(ist) [first [,last]]
1062List source code for the current file.
1063Without arguments, list 11 lines around the current line
1064or continue the previous listing.
1065With one argument, list 11 lines starting at that line.
1066With two arguments, list the given range;
1067if the second argument is less than the first, it is a count."""
1068
1069    def help_args(self):
1070        self.help_a()
1071
1072    def help_a(self):
1073        print >>self.stdout, """a(rgs)
1074Print the arguments of the current function."""
1075
1076    def help_p(self):
1077        print >>self.stdout, """p expression
1078Print the value of the expression."""
1079
1080    def help_pp(self):
1081        print >>self.stdout, """pp expression
1082Pretty-print the value of the expression."""
1083
1084    def help_exec(self):
1085        print >>self.stdout, """(!) statement
1086Execute the (one-line) statement in the context of
1087the current stack frame.
1088The exclamation point can be omitted unless the first word
1089of the statement resembles a debugger command.
1090To assign to a global variable you must always prefix the
1091command with a 'global' command, e.g.:
1092(Pdb) global list_options; list_options = ['-l']
1093(Pdb)"""
1094
1095    def help_run(self):
1096        print """run [args...]
1097Restart the debugged python program. If a string is supplied, it is
1098split with "shlex" and the result is used as the new sys.argv.
1099History, breakpoints, actions and debugger options are preserved.
1100"restart" is an alias for "run"."""
1101
1102    help_restart = help_run
1103
1104    def help_quit(self):
1105        self.help_q()
1106
1107    def help_q(self):
1108        print >>self.stdout, """q(uit) or exit - Quit from the debugger.
1109The program being executed is aborted."""
1110
1111    help_exit = help_q
1112
1113    def help_whatis(self):
1114        print >>self.stdout, """whatis arg
1115Prints the type of the argument."""
1116
1117    def help_EOF(self):
1118        print >>self.stdout, """EOF
1119Handles the receipt of EOF as a command."""
1120
1121    def help_alias(self):
1122        print >>self.stdout, """alias [name [command [parameter parameter ...]]]
1123Creates an alias called 'name' the executes 'command'.  The command
1124must *not* be enclosed in quotes.  Replaceable parameters are
1125indicated by %1, %2, and so on, while %* is replaced by all the
1126parameters.  If no command is given, the current alias for name
1127is shown. If no name is given, all aliases are listed.
1128
1129Aliases may be nested and can contain anything that can be
1130legally typed at the pdb prompt.  Note!  You *can* override
1131internal pdb commands with aliases!  Those internal commands
1132are then hidden until the alias is removed.  Aliasing is recursively
1133applied to the first word of the command line; all other words
1134in the line are left alone.
1135
1136Some useful aliases (especially when placed in the .pdbrc file) are:
1137
1138#Print instance variables (usage "pi classInst")
1139alias pi for k in %1.__dict__.keys(): print "%1.",k,"=",%1.__dict__[k]
1140
1141#Print instance variables in self
1142alias ps pi self
1143"""
1144
1145    def help_unalias(self):
1146        print >>self.stdout, """unalias name
1147Deletes the specified alias."""
1148
1149    def help_commands(self):
1150        print >>self.stdout, """commands [bpnumber]
1151(com) ...
1152(com) end
1153(Pdb)
1154
1155Specify a list of commands for breakpoint number bpnumber.  The
1156commands themselves appear on the following lines.  Type a line
1157containing just 'end' to terminate the commands.
1158
1159To remove all commands from a breakpoint, type commands and
1160follow it immediately with  end; that is, give no commands.
1161
1162With no bpnumber argument, commands refers to the last
1163breakpoint set.
1164
1165You can use breakpoint commands to start your program up again.
1166Simply use the continue command, or step, or any other
1167command that resumes execution.
1168
1169Specifying any command resuming execution (currently continue,
1170step, next, return, jump, quit and their abbreviations) terminates
1171the command list (as if that command was immediately followed by end).
1172This is because any time you resume execution
1173(even with a simple next or step), you may encounter
1174another breakpoint--which could have its own command list, leading to
1175ambiguities about which list to execute.
1176
1177   If you use the 'silent' command in the command list, the
1178usual message about stopping at a breakpoint is not printed.  This may
1179be desirable for breakpoints that are to print a specific message and
1180then continue.  If none of the other commands print anything, you
1181see no sign that the breakpoint was reached.
1182"""
1183
1184    def help_pdb(self):
1185        help()
1186
1187    def lookupmodule(self, filename):
1188        """Helper function for break/clear parsing -- may be overridden.
1189
1190        lookupmodule() translates (possibly incomplete) file or module name
1191        into an absolute file name.
1192        """
1193        if os.path.isabs(filename) and  os.path.exists(filename):
1194            return filename
1195        f = os.path.join(sys.path[0], filename)
1196        if  os.path.exists(f) and self.canonic(f) == self.mainpyfile:
1197            return f
1198        root, ext = os.path.splitext(filename)
1199        if ext == '':
1200            filename = filename + '.py'
1201        if os.path.isabs(filename):
1202            return filename
1203        for dirname in sys.path:
1204            while os.path.islink(dirname):
1205                dirname = os.readlink(dirname)
1206            fullname = os.path.join(dirname, filename)
1207            if os.path.exists(fullname):
1208                return fullname
1209        return None
1210
1211    def _runscript(self, filename):
1212        # The script has to run in __main__ namespace (or imports from
1213        # __main__ will break).
1214        #
1215        # So we clear up the __main__ and set several special variables
1216        # (this gets rid of pdb's globals and cleans old variables on restarts).
1217        import __main__
1218        __main__.__dict__.clear()
1219        __main__.__dict__.update({"__name__"    : "__main__",
1220                                  "__file__"    : filename,
1221                                  "__builtins__": __builtins__,
1222                                 })
1223
1224        # When bdb sets tracing, a number of call and line events happens
1225        # BEFORE debugger even reaches user's code (and the exact sequence of
1226        # events depends on python version). So we take special measures to
1227        # avoid stopping before we reach the main script (see user_line and
1228        # user_call for details).
1229        self._wait_for_mainpyfile = 1
1230        self.mainpyfile = self.canonic(filename)
1231        self._user_requested_quit = 0
1232        statement = 'execfile(%r)' % filename
1233        self.run(statement)
1234
1235# Simplified interface
1236
1237def run(statement, globals=None, locals=None):
1238    Pdb().run(statement, globals, locals)
1239
1240def runeval(expression, globals=None, locals=None):
1241    return Pdb().runeval(expression, globals, locals)
1242
1243def runctx(statement, globals, locals):
1244    # B/W compatibility
1245    run(statement, globals, locals)
1246
1247def runcall(*args, **kwds):
1248    return Pdb().runcall(*args, **kwds)
1249
1250def set_trace():
1251    Pdb().set_trace(sys._getframe().f_back)
1252
1253# Post-Mortem interface
1254
1255def post_mortem(t=None):
1256    # handling the default
1257    if t is None:
1258        # sys.exc_info() returns (type, value, traceback) if an exception is
1259        # being handled, otherwise it returns None
1260        t = sys.exc_info()[2]
1261        if t is None:
1262            raise ValueError("A valid traceback must be passed if no "
1263                                               "exception is being handled")
1264
1265    p = Pdb()
1266    p.reset()
1267    p.interaction(None, t)
1268
1269def pm():
1270    post_mortem(sys.last_traceback)
1271
1272
1273# Main program for testing
1274
1275TESTCMD = 'import x; x.main()'
1276
1277def test():
1278    run(TESTCMD)
1279
1280# print help
1281def help():
1282    for dirname in sys.path:
1283        fullname = os.path.join(dirname, 'pdb.doc')
1284        if os.path.exists(fullname):
1285            sts = os.system('${PAGER-more} '+fullname)
1286            if sts: print '*** Pager exit status:', sts
1287            break
1288    else:
1289        print 'Sorry, can\'t find the help file "pdb.doc"',
1290        print 'along the Python search path'
1291
1292def main():
1293    if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
1294        print "usage: pdb.py scriptfile [arg] ..."
1295        sys.exit(2)
1296
1297    mainpyfile =  sys.argv[1]     # Get script filename
1298    if not os.path.exists(mainpyfile):
1299        print 'Error:', mainpyfile, 'does not exist'
1300        sys.exit(1)
1301
1302    del sys.argv[0]         # Hide "pdb.py" from argument list
1303
1304    # Replace pdb's dir with script's dir in front of module search path.
1305    sys.path[0] = os.path.dirname(mainpyfile)
1306
1307    # Note on saving/restoring sys.argv: it's a good idea when sys.argv was
1308    # modified by the script being debugged. It's a bad idea when it was
1309    # changed by the user from the command line. There is a "restart" command
1310    # which allows explicit specification of command line arguments.
1311    pdb = Pdb()
1312    while True:
1313        try:
1314            pdb._runscript(mainpyfile)
1315            if pdb._user_requested_quit:
1316                break
1317            print "The program finished and will be restarted"
1318        except Restart:
1319            print "Restarting", mainpyfile, "with arguments:"
1320            print "\t" + " ".join(sys.argv[1:])
1321        except SystemExit:
1322            # In most cases SystemExit does not warrant a post-mortem session.
1323            print "The program exited via sys.exit(). Exit status: ",
1324            print sys.exc_info()[1]
1325        except SyntaxError:
1326            traceback.print_exc()
1327            sys.exit(1)
1328        except:
1329            traceback.print_exc()
1330            print "Uncaught exception. Entering post mortem debugging"
1331            print "Running 'cont' or 'step' will restart the program"
1332            t = sys.exc_info()[2]
1333            pdb.interaction(None, t)
1334            print "Post mortem debugger finished. The " + mainpyfile + \
1335                  " will be restarted"
1336
1337
1338# When invoked as main program, invoke the debugger on a script
1339if __name__ == '__main__':
1340    import pdb
1341    pdb.main()
1342