pygdb now saves absolute breakpoint paths
[pygdb.git] / GdbTerminal.py
old mode 100755 (executable)
new mode 100644 (file)
index bc5d1e7..81a6300
@@ -23,38 +23,30 @@ class GdbTerminal (DbgTerminal.DbgTerminal):
        def getArgv(self):
                return ["gdb", "--fullname", string.split(self.clientCmd)[0]]
 
-       def setPty(self, pty):
-               ttyname = os.ttyname(pty)
-               self.feed_child("set inferior-tty %s\n" % (ttyname,))
-
        def setRun(self):
-
-               his = self.getHistoryLen()
                argv = string.join(string.split(self.clientCmd)[1:])
                self.feed_child("run " + argv + "\n")
-               return self.waitForActivation(his)
-
 
        def setContinue(self):
-               his = self.getHistoryLen()
                self.feed_child("cont\n");
-               return self.waitForActivation(his)
 
        def setStepover(self):
-               his = self.getHistoryLen()
                self.feed_child("next\n");
-               return self.waitForActivation(his)
 
        def setStepin(self):
-               his = self.getHistoryLen()
                self.feed_child("step\n");
-               return self.waitForActivation(his)
 
        def setQuit(self):
                self.feed_child("quit\n")
                self.waitForNewline()
                self.feed_child("y\n");
 
+       def setPty(self, pty):
+               ttyname = os.ttyname(pty)
+               len = self.getHistoryLen()
+               self.feed_child("set inferior-tty %s\n" % (ttyname,))
+               self.waitForPrompt(len)
+
        def setBreakpoint(self, file, lineno, condition=None):
                his = self.getHistoryLen()
                if condition==None:
@@ -63,36 +55,37 @@ class GdbTerminal (DbgTerminal.DbgTerminal):
                        self.feed_child("break %s:%s if %s\n" % \
                                        (file, str(lineno), condition))
 
-               rx = re.compile("^Breakpoint |^No|^\(gdb\) ")
+               rx = "^Breakpoint |^No |^\(gdb\) "
                his, response = self.waitForRx(rx, his)
 
-               print his, response
+               answer = None
 
                if response[0:10] == "Breakpoint":
-                       return string.split(response)[1].strip()
-               if response[0:5] == "(gdb)":
-                       return None
+                       answer = string.split(response)[1].strip()
+               
+               #Wants an answer: "No"
                if response[0:14] == "No source file":
                        self.feed_child("n\n");
-                       return None
-               if response[0:3] == "No ":
-                       return None
-                       
-               return NotImplementedError()
+
+               #Wait again for (gdb)...
+               self.waitForPrompt(his)
+
+               return answer
+
 
        def delBreakpoint(self, breakpoint):
+               his = self.getHistoryLen()
                self.feed_child("del breakpoint %s\n" % (breakpoint,))
+               self.waitForPrompt(his)
 
        def getBreakpoints(self):
                starthis = self.getHistoryLen()
                self.feed_child("info breakpoints\n")
+               endhis, response = self.waitForPrompt(starthis)
 
-               rx = re.compile("^\(gdb\) ")
-               endhis, response = self.waitForRx(rx, starthis)
-
-
-               rxbp1 = re.compile("^\d+\s+breakpoint")
-               rxbp2 = re.compile("^\tstop only if")
+               rxbp = re.compile("^\d+\s+breakpoint")
+               rxpos = re.compile("^.* at \S+:\d+$")
+               rxcond = re.compile("^\tstop only if")
 
                bpnts = []
                bplines = self.history[starthis+1:endhis]
@@ -102,17 +95,23 @@ class GdbTerminal (DbgTerminal.DbgTerminal):
                while i<len(bplines):
                        line = bplines[i]
 
-                       if not rxbp1.search(line):
+                       if not rxbp.search(line):
                                i += 1
                                continue
+       
+                       #Get number of breakpoint
+                       no = string.split(line)[0]
+
+                       #This line does not contain the file!
+                       if not rxpos.search(line):
+                               i += 1
+                               line = bplines[i]
 
-                       splits = string.split(line)
-                       no = splits[0]
-                       pos = splits[-1]
+                       pos = string.split(line)[-1]
                        [file,lineno] = string.split(pos,":")
                        cond = None
 
-                       if i+1<len(bplines) and rxbp2.search(bplines[i+1]):
+                       if i+1<len(bplines) and rxcond.search(bplines[i+1]):
                                i +=1
                                line = bplines[i]
                                pre,cond = string.split(line,"if")
@@ -129,10 +128,7 @@ class GdbTerminal (DbgTerminal.DbgTerminal):
 
                his = self.getHistoryLen()
                self.feed_child("print " + expr + "\n")
-
-               rx = re.compile("^\(gdb\) $")
-               his, response = self.waitForRx(rx, his)
-
+               his, response = self.waitForPrompt(his)
                answer = self.history[his-1]
 
                if len(string.split(answer, "=")) == 1:
@@ -141,21 +137,72 @@ class GdbTerminal (DbgTerminal.DbgTerminal):
                split = string.split(answer, "=")
                return string.join(split[1:], "=").strip()
 
+       
+       def listCodeSnippet(self):
+               starthis = self.getHistoryLen()
+               self.feed_child("list\n")
+               endhis, response = self.waitForPrompt(starthis)
 
-       def waitForActivation(self, his=None):
+               text = string.join(self.history[starthis:endhis], "\n")
+               return text
 
-               self.setActive(False)
-               rx = re.compile("^\(gdb\) $")
-               his, reponse = self.waitForRx(rx,his)
-               self.setActive(True)
 
-               if self.history[his-1][0:2]=="\x1a\x1a":
-                       tuples = string.split(self.history[his-1][2:], ":")
-                       return tuples[0:2]
+       def waitForPrompt(self, his):
+               rx = "^\(gdb\)"
+               return self.waitForRx(rx,his)
+
+
+       def testForActivity(self, his):
+               """Test whether debugger got active again"""
+                       
+               line = self.history[his]
+
+               if string.find(line, "\x1a\x1a") == 0:
+                       tuples = string.split(line[2:], ":")
+                       tuples[1] = int(tuples[1])
+                       return "break", [tuples[0], int(tuples[1])]
+
+               if string.find(line, "Program exited") == 0:
+                       code = string.split(line)[-1]
+
+                       codeno = 0
+               
+                       #Parse the octal number
+                       if code[0] == "O":
+                               code = code[1:-1]
+                               for c in code:
+                                       codeno = codeno*8 + int(c)
+
+                       return "exited", codeno
 
                return None
 
 
+       def testForInactivity(self, his):
+               """Test whether debugger got inactive"""                
+               line = self.history[his]
+
+               if string.find(line, "Starting program:") == 0:
+                       prog = string.join( string.split(line)[1:])
+                       return "started", prog
+
+               if string.find(line, "Continuing.") == 0:
+                       return "continued", None
+
+               if string.find(line, "\x1a\x1a") == 0:
+                       rxcont = re.compile("^\(gdb\)\s+(cont|step|next|stepi|nexti)")
+
+                       if rxcont.search(self.history[his-1]):
+                               return "stepped", None
+
+               return None
+
+
+
+
+
+
+
 
 if __name__ == "__main__":