(line[:3] == '"""') or line[:3] == "'''" ):            print '*** Blank or comment'            return 0        # When a file is read in and a breakpoint is at        # the 'def' statement, the system stops there at        # code parse time.  We don't want that, so all breakpoints        # set at 'def' statements are moved one line onward        if line[:3] == 'def':            instr = ''            brackets = 0            while 1:                skipone = 0                for c in line:                    if instr:                        if skipone:                            skipone = 0                        elif c == '\\':                            skipone = 1                        elif c == instr:                            instr = ''                    elif c == '#':                        break                    elif c in ('"',"'"):                        instr = c                    elif c in ('(','{','['):                        brackets = brackets + 1                    elif c in (')','}',']'):                        brackets = brackets - 1                lineno = lineno+1                line = linecache.getline(filename, lineno)                if not line:                    print 'end of file'                    return 0                line = line.strip()                if not line: continue   # Blank line                if brackets <= 0 and line[0] not in ('#','"',"'"):                    break        return lineno    def do_enable(self, arg):        args = arg.split()        for i in args:            try:                i = int(i)            except ValueError:                print 'Breakpoint index %r is not a number' % i                continue            if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):                print 'No breakpoint numbered', i                continue            bp = bdb.Breakpoint.bpbynumber[i]            if bp:                bp.enable()    def do_disable(self, arg):        args = arg.split()        for i in args:            try:                i = int(i)            except ValueError:                print 'Breakpoint index %r is not a number' % i                continue                        if not (0 <= i < len(bdb.Breakpoint.bpbynumber)):                print 'No breakpoint numbered', i                continue            bp = bdb.Breakpoint.bpbynumber[i]            if bp:                bp.disable()    def do_condition(self, arg):        # arg is breakpoint number and condition        args = arg.split(' ', 1)        bpnum = int(args[0].strip())        try:            cond = args[1]        except:            cond = None        bp = bdb.Breakpoint.bpbynumber[bpnum]        if bp:            bp.cond = cond            if not cond:                print 'Breakpoint', bpnum,                print 'is now unconditional.'    def do_ignore(self,arg):        """arg is bp number followed by ignore count."""        args = arg.split()        bpnum = int(args[0].strip())        try:            count = int(args[1].strip())        except:            count = 0        bp = bdb.Breakpoint.bpbynumber[bpnum]        if bp:            bp.ignore = count            if (count > 0):                reply = 'Will ignore next '                if (count > 1):                    reply = reply + '%d crossings' % count                else:                    reply = reply + '1 crossing'                print reply + ' of breakpoint %d.' % bpnum            else:                print 'Will stop next time breakpoint',                print bpnum, 'is reached.'    def do_clear(self, arg):        """Three possibilities, tried in this order:        clear -> clear all breaks, ask for confirmation        clear file:lineno -> clear all breaks at file:lineno        clear bpno bpno ... -> clear breakpoints by number"""        if not arg:            try:                reply = raw_input('Clear all breaks? ')            except EOFError:                reply = 'no'            reply = reply.strip().lower()            if reply in ('y', 'yes'):                self.clear_all_breaks()            return        if ':' in arg:            # Make sure it works for "clear C:\foo\bar.py:12"            i = arg.rfind(':')            filename = arg[:i]            arg = arg[i+1:]            try:                lineno = int(arg)            except:                err = "Invalid line number (%s)" % arg            else:                err = self.clear_break(filename, lineno)            if err: print '***', err            return        numberlist = arg.split()        for i in numberlist:            err = self.clear_bpbynumber(i)            if err:                print '***', err            else:                print 'Deleted breakpoint %s ' % (i,)    do_cl = do_clear # 'c' is already an abbreviation for 'continue'    def do_where(self, arg):        self.print_stack_trace()    do_w = do_where    do_bt = do_where    def do_up(self, arg):        if self.curindex == 0:            print '*** Oldest frame'        else:            self.curindex = self.curindex - 1            self.curframe = self.stack[self.curindex][0]            self.print_stack_entry(self.stack[self.curindex])            self.lineno = None    do_u = do_up    def do_down(self, arg):        if self.curindex + 1 == len(self.stack):            print '*** Newest frame'        else:            self.curindex = self.curindex + 1            self.curframe = self.stack[self.curindex][0]            self.print_stack_entry(self.stack[self.curindex])            self.lineno = None    do_d = do_down    def do_step(self, arg):        self.set_step()        return 1    do_s = do_step    def do_next(self, arg):        self.set_next(self.curframe)        return 1    do_n = do_next    def do_return(self, arg):        self.set_return(self.curframe)        return 1    do_r = do_return    def do_continue(self, arg):        self.set_continue()        return 1    do_c = do_cont = do_continue    def do_quit(self, arg):        self.set_quit()        return 1    do_q = do_quit    do_exit = do_quit    def do_EOF(self, arg):        print        self.set_quit()        return 1    def do_args(self, arg):        f = self.curframe        co = f.f_code        dict = f.f_locals        n = co.co_argcount        if co.co_flags & 4: n = n+1        if co.co_flags & 8: n = n+1        for i in range(n):            name = co.co_varnames[i]            print name, '=',            if dict.has_key(name): print dict[name]            else: print "*** undefined ***"    do_a = do_args    def do_retval(self, arg):        if self.curframe.f_locals.has_key('__return__'):            print self.curframe.f_locals['__return__']        else:            print '*** Not yet returned!'    do_rv = do_retval    def do_p(self, arg):        try:            value = eval(arg, self.curframe.f_globals,                            self.curframe.f_locals)        except:            t, v = sys.exc_info()[:2]            if type(t) == type(''):                exc_type_name = t            else: exc_type_name = t.__name__            print '***', exc_type_name + ':', `v`            return        print `value`    def do_list(self, arg):        self.lastcmd = 'list'        last = None        if arg:            try:                x = eval(arg, {}, {})                if type(x) == type(()):                    first, last = x                    first = int(first)                    last = int(last)                    if last < first:                        # Assume it's a count                        last = first + last                else:                    first = max(1, int(x) - 5)            except:                print '*** Error in argument:', `arg`                return        elif self.lineno is None:            first = max(1, self.curframe.f_lineno - 5)        else:            first = self.lineno + 1        if last is None:            last = first + 10        filename = self.curframe.f_code.co_filename        breaklist = self.get_file_breaks(filename)        try:            for lineno in range(first, last+1):                line = linecache.getline(filename, lineno)                if not line:                    print '[EOF]'                    break                else:                    s = `lineno`.rjust(3)                    if len(s) < 4: s = s + ' '                    if lineno in breaklist: s = s + 'B'                    else: s = s + ' '                    if lineno == self.curframe.f_lineno:                        s = s + '->'                    print s + '\t' + line,                    self.lineno = lineno        except KeyboardInterrupt:            pass    do_l = do_list    def do_whatis(self, arg):        try:            value = eval(arg, self.curframe.f_globals,                            self.curframe.f_locals)        except:            t, v = sys.exc_info()[:2]            if type(t) == type(''):                exc_type_name = t            else: exc_type_name = t.__name__            print '***', exc_type_name + ':', `v`            return        code = None        # Is it a function?        try: code = value.func_code        except: pass        if code:            print 'Function', code.co_name            return        # Is it an instance method?        try: code = value.im_func.func_code        except: pass        if code:            print 'Method', code.co_name            return        # None of the above...        print type(value)    def do_alias(self, arg):        args = arg.split()        if len(args) == 0:            keys = self.aliases.keys()            keys.sort()            for alias in keys:                print "%s = %s" % (alias, self.aliases[alias])            return        if self.aliases.has_key(args[0]) and len (args) == 1:            print "%s = %s" % (args[0], self.aliases[args[0]])        else:            self.aliases[args[0]] = ' '.join(args[1:])    def do_unalias(self, arg):        args = arg.split()        if len(args) == 0: return        if self.aliases.has_key(args[0]):            del self.aliases[args[0]]