Add LICENSE

[pygdb.git] / Configuration.py

diff --git a/Configuration.py b/Configuration.py
old mode 100755 (executable)
new mode 100644 (file)
index a8b4abf..778afb2
--- a/Configuration.py
+++ b/Configuration.py
@@ -13,16 +13,25 @@ import StatusWindow
 class Configuration:
 
        def __init__(self):
+               self.clear()
+
+
+       def clear(self):
                self.breakpoints = []
                self.watches = []
                self.ints = []
+               self.currfile, self.currlineno = None, 0
+               self.command = None
 
 
        def load(self, filename):
                try:
+                       self.clear()
+
                        cnt = 0
                        #Parse all lines
-                       for line in file(filename).readlines():
+                       f = file(filename, "r")
+                       for line in f.readlines():
                                cnt += 1
 
                                #Get command and tail
@@ -35,40 +44,58 @@ class Configuration:
                                        self.parseWatch(tail)
                                elif cmd == "int":
                                        self.parseInt(tail)
+                               elif cmd == "currpos":
+                                       self.parseCurrpos(tail)
+                               elif cmd == "cmd":
+                                       self.parseCommand(tail)
                                else:
                                        cnt -= 1
                                        print "Unkown command", cmd
+                       f.close()
                        return cnt
+
                except IOError:
                        return None
 
 
        def store(self, filename):
+               try:
+                       f = file(filename, "w")
+
+                       for b in self.breakpoints:
+                               self.__writeBreak(f, b)
 
-               f = file(filename, "w")
+                       for w in self.watches:
+                               self.__writeWatch(f, w)
 
-               for b in self.breakpoints:
-                       self.__writeBreak(f, b)
+                       for s in self.ints:
+                               self.__writeInt(f, s)
 
-               for w in self.watches:
-                       self.__writeWatch(f, w)
+                       if self.isCurrposSet():
+                               self.__writeCurrpos(f)
 
-               for s in self.ints:
-                       self.__writeInt(f, s)
+                       if self.getCommand() != None:
+                               self.__writeCommand(f)
+
+                       f.close()
+                       return True
+
+               except IOError:
+                       return False
 
 
 
        def parseBreak(self, tail):
 
                tail = tail.strip()
-               rx = re.compile("^[\w\._\-]+:\d+(\s+if\s+\S+.*)?$")
+               rx = re.compile("^[\w/\._\-]+:\d+(\s+if\s+\S+.*)?$")
 
                if not rx.search(tail):
                        print "Wrong breakpoint format:", tail
                        return
 
-               preif = string.split(tail, "if")[0].strip()
-               postif = string.join( string.split(tail, "if")[1:], "if").strip()
+               preif = string.split(tail, " if ")[0].strip()
+               postif = string.join( string.split(tail, " if ")[1:], " if ").strip()
 
                [file,lineno] = string.split(preif, ":")
                lineno = int(lineno)
@@ -94,6 +121,23 @@ class Configuration:
        def parseWatch(self, tail):
                self.addWatch(tail)
 
+       def parseCurrpos(self, tail):
+
+               tail = tail.strip()
+               rx = re.compile("^[\w/\._\-]+:\d+$")
+
+               if not rx.search(tail):
+                       print "Wrong current position format:", tail
+                       return
+
+               [file,lineno] = string.split(tail, ":")
+               lineno = int(lineno)
+
+               self.setCurrpos(file, lineno)
+
+       def parseCommand(self, tail):
+               self.command = tail
+
 
        def __writeBreak(self, f, b):
                if b["cond"] != None:
@@ -107,16 +151,43 @@ class Configuration:
        def __writeWatch(self, f, w):
                f.write("watch %(expr)s\n" % w)
 
+       def __writeCurrpos(self, f):
+               f.write("currpos %s:%d\n" % (self.currfile, self.currlineno))
 
-       def addBreak(self, file, lineno, cond=None):            
-               self.breakpoints += [ {"file" : file, "lineno" : lineno, "cond" : cond} ]
+       def __writeCommand(self, f):
+               f.write("cmd %s\n" % self.command)
+
+
+       def addBreak(self, file, lineno, cond=None):
+               bp = {"file" : file, "lineno" : lineno, "cond" : cond}
+               if not bp in self.breakpoints:
+                       self.breakpoints += [bp]
 
        def addInt(self, name, val):
-               self.ints += [{"name": name, "val": val}]
+               i = {"name": name, "val": val}
+               if not i in self.ints:
+                       self.ints += [i]
 
        def addWatch(self, expr):
-               self.watches += [ {"expr" : expr.strip() } ]
+               w = {"expr" : expr.strip() }
+               if not w in self.watches:
+                       self.watches += [w]
+
+       def setCurrpos(self, file, lineno):
+               self.currfile, self.currlineno = file, lineno
+
+       def isCurrposSet(self):
+               return self.currfile!=None
+       
+
+       def delCurrpos(self):
+               self.currfile = None
+
+       def setCommand(self,cmd):
+               self.command = cmd
 
+       def getCommand(self):
+               return self.command
 
        def findInt(self, name):
                for i in self.ints:
@@ -128,7 +199,8 @@ class Configuration:
        def __str__(self):
                return "breakpoints=" + str(self.breakpoints) + \
                                ", watches=" + str(self.watches) + \
-                               ", ints=" + str(self.ints)
+                               ", ints=" + str(self.ints) + \
+                               ", currpos=" + str((self.currfile, self.currlineno))