X-Git-Url: http://rtime.felk.cvut.cz/gitweb/omk.git/blobdiff_plain/00eecee14fc528a068a6e239e8351313ee3b449d..f1583dd6b46ac7da1cd38fd3fbc55b528fe5911e:/omkbuild.py

diff --git a/omkbuild.py b/omkbuild.py
index ed08875..f409563 100755
--- a/omkbuild.py
+++ b/omkbuild.py
@@ -13,9 +13,9 @@ Snippet syntax:
   documentation := comment*
   rules ::= text
   
-  comment ::= '#' text
-  empty-comment ::= '#'
-  text ::= [^#] ...
+  comment ::= '#' text '\n'
+  empty-comment ::= '#' '\n'
+  text ::= [^#] ... '\n'
 
  Makefile.rules policies:
 
@@ -23,29 +23,72 @@ Snippet syntax:
      as they are in snippets i.e. copyrights, documentations and rules.
 
    * On the first line of each part of the Makefile.rules, there is
-     special mart of the form #OMK@<snippet file name><EOL>. This mark
-     is used for splitting Makefile.rules back to the original
-     snippets.
+     special mark of the form:
 
+       #OMK:<snippet file name>[@<included from snippet>]<EOL>
+
+     This mark is used for splitting modified Makefile.rules back to
+     the original snippets. If <snippet file name> starts with __, it
+     is ignored during splitting.
+
+   * Toplevel snippet has name in the forb Makefile.rules.* and no
+     other (included) snippet has such name.
 """
 
 from optparse import OptionParser
 import os
+import os.path
 import sys
 import string
 import re
 
+rulesDir = "rules"
+snippetsDir = "snippets"
+
+class LineList(list):
+    """List of text lines"""
+    def getDiff(self, other):
+        s = ''
+        for i in range(len(self)):
+            if i >= len(other):
+                s += ("  Line %d differs!\n" % i)
+                s += "  -"+self[i].rstrip() + "\n"
+                s += "  +\n"
+                break
+            if self[i] != other[i]:
+                s += ("  Line %d differs!\n" % i)
+                s += "  -"+self[i].rstrip() + "\n"
+                s += "  +"+other[i].rstrip() + "\n"
+                break
+        return s
+    
+    def __str__(self):
+        s = ''
+        for l in self: s += l
+        return s
+
+    def loadFromFile(self, fname):
+        """Loads itself from file."""
+        try:
+            f = open(fname, "r")
+        except IOError:
+            sys.stderr.write("Cannot open %s\n" % fname)
+            sys.exit(1)
+            
+        self.extend(f.readlines())
+        f.close
+
 class Snippet:
-    def __init__(self, fname = None):
+    def __init__(self, fname = None, name = ""):
         """Initializes the snippet and if fname is given, reads it
         from file"""
-        self.name = ""
-        self.legal = []
-        self.doc = []
-        self.code = []
-        if fname: self.readFromFile(fname)
+        self.name = name
+        self.legal = LineList()
+        self.doc = LineList()
+        self.code = LineList()
+        if fname: self.loadFromFile(fname)
         
-    def readFromFile(self, fname):
+    def loadFromFile(self, fname):
         """Loads snippet from file."""
         self.name = fname
         f = open(fname, "r")
@@ -54,9 +97,11 @@ class Snippet:
          
         f.close
 
+    def addCodeLine(self, line):
+        self.code.append(line)
+
     def readLines(self, lines):
-        """Parses the snippet given in the list and stores it in
-        self."""
+        """Parses the snippet given as a list and stores it in itself."""
         currentPart = self.legal
         counter = 0
 
@@ -64,45 +109,203 @@ class Snippet:
             if currentPart == self.legal:
                 if line.strip() == "#": counter += 1
                 else: counter = 0
-                if counter == 2: currentPart = self.doc
             if line[0] != "#": currentPart = self.code
 
             currentPart.append(line)
 
+            if counter == 2:
+                currentPart = self.doc
+                counter = 0
+
+
         if not self.doc:
             self.doc = self.legal
-            self.legal = []
+            self.legal = LineList()
 
-    def asLines(self):
-        lines = []
+    def asLinesList(self):
+        lines = LineList()
         for type in ['legal', 'doc', 'code']:
             for line in self.__dict__[type]:
                 lines.append(line)
         return lines
 
     def __str__(self):
-        s = ""
-        lines = self.asLines()
-        for l in lines: s += l
-        return s
+        return str(self.asLinesList())
 
     def __repr__(self):
         s = "<Snippet: %s>" % self.name
         return s
 
     def __cmp__(self, other):
-        ret = self.name.__cmp__(other.name)
+        ret = cmp(self.name, other.name)
         if ret != 0: return ret
-        ret = self.legal.__cmp__(other.legal)
+        ret = cmp(self.legal, other.legal)
         if ret != 0: return ret
-        ret = self.doc.__cmp__(other.doc)
+        ret = cmp(self.doc, other.doc)
         if ret != 0: return ret
-        ret = self.code.__cmp__(other.code)
+        ret = cmp(self.code, other.code)
         return ret
 
+    def __getitem__(self, key):
+        return {
+            'legal': self.legal,
+            'doc'  : self.doc,
+            'code' : self.code
+            }[key]
+
+    def getDiff(self, other):
+        return self.asLinesList().getDiff(other.asLinesList())
+
+class Snippets:
+    """Collection of snippets, where snippets can be accessed
+    individually by name (like dictionary) or sequentionaly in the
+    order they were added."""
+    def __init__(self):
+        self._snippets = dict()
+        self._order = list()
+
+    def __iadd__(self, snippet):
+        assert isinstance(snippet, Snippet)
+        self._snippets[snippet.name] = snippet
+        self._order += [snippet]
+        return self
+
+    def __getitem__(self, key):
+        return self._snippets[key]
+
+    def __contains__(self, item):
+        return item in self._snippets
+
+    def __iter__(self):
+        return iter(self._order)
+
+    def __cmp__(self, other):
+        return cmp(self._snippets, other._snippets)
+
+    def loadFromFiles(self, fnames):
+        """Reads the snippets from several files and adds them to itself."""
+        for fn in fnames:
+            self += Snippet(fn)
+        
+    def loadFromDict(self, snipDict):
+        """Adds snippets to itself from dictionary of LineLists."""
+        for s in snipDict:
+            snip = Snippet()
+            snip.name = s
+            snip.readLines(snipDict[s])
+            self += snip
+
+    def getDiff(self, other):
+        assert isinstance(other, Snippets)
+        s = ''
+        for snip in self:
+            if (snip.name[0:2] == '__'): continue
+            if (snip != other[snip.name]):
+                s += "Snippet %s:\n" % snip.name
+                s += snip.getDiff(other[snip.name])
+        return s
+
+# Include directoves matching this r.e. will be replaced by this script
+reInclude = re.compile("^include ([^ ]*) #omkbuild")
+
+class MakefileRules(LineList):
+    def __init__(self):
+        self.snippets = Snippets()
+        self.rules = LineList()
+
+    def _includeSnippets(self, filename, baseFileName="", onlyLoadSnippets=False):
+        """Recursively traverses snippets according to include
+        directives. If onlyLoadSnippets is True, self.rules is not
+        modified ..."""
+
+        if onlyLoadSnippets:
+            if filename in self.snippets:
+                sys.stderr.write("Error: Snippet included more than once\n")
+                # This is not allowed becouse it would cause problems
+                # during spliting
+                sys.exit(1)
+            self.snippets += Snippet(filename)
+
+        lines = self.snippets[filename]['code']
+
+        addMarker = 1 # The first line of the snippet should be marked
+        for line in lines:
+            match = reInclude.match(line)
+            if match:
+                # Include other snippet
+                self._includeSnippets(match.group(1).strip(),\
+                                      filename,
+                                      onlyLoadSnippets)
+                addMarker = 2 # The next line after include should be marked
+            else:
+                # Add this line to rules
+                if addMarker:
+                    if addMarker==1:
+                        line = string.rstrip(line).ljust(80)+" #OMK:%s@%s\n"%(filename,baseFileName)
+                    elif addMarker==2:
+                        line = string.rstrip(line).ljust(80)+" #OMK:%s\n"%(filename)
+                    addMarker = 0
+                if not onlyLoadSnippets:
+                    self.rules += [line]
+
+    def combineFrom(self, topLevelSnippet, onlyCheck=False):
+        """Produces self.rules from the topLevelSnippet and all
+        snippets included directly or indirectly from it."""
+        self.rules = LineList()
+
+        if not onlyCheck:
+            self._includeSnippets(topLevelSnippet, onlyLoadSnippets=True)
+
+        # Append legal and doc parts
+        for type in ['legal', 'doc']:
+            for snip in self.snippets:
+                lines = snip[type]
+                if len(lines) == 0: continue
+                firstLine = string.rstrip(lines[0])
+                self.rules += [firstLine.ljust(80)+" #OMK:%s\n"%snip.name]
+                self.rules += lines[1:]
+                #self.rules += ['a'] # test error
+
+        # Append code parts
+        self._includeSnippets(topLevelSnippet)
+
+
+    def split(self):
+        """Split self.rules to the original snippets in self.snippets."""
+        self.snippets = Snippets()
+        snipDict = self._getSnipDicts()
+        self.snippets.loadFromDict(snipDict)
+
+    def _getSnipDicts(self):
+        """Split self.rules to the original snippets, which are
+        returened as dictionary of LineLists."""
+        snipBegin = re.compile("^(.*)#OMK:([^@]*)(?:@(.*))?\n$")
+        snipDict = dict()
+        currentLinesList = None
+
+        for line in self.rules:
+            match = snipBegin.match(line)
+            if match:
+                line = match.group(1).rstrip() + "\n"
+                snipName = match.group(2)
+                includedFrom = match.group(3)
+                if includedFrom:
+                    if not includedFrom in snipDict: snipDict[includedFrom] = LineList()
+                    snipDict[includedFrom].append("include %s #omkbuild\n" % snipName);
+
+                if not snipName in snipDict:
+                    snipDict[snipName] = LineList()
+                currentLinesList = snipDict[snipName]
+            
+            if currentLinesList != None:
+                currentLinesList.append(line);
+                
+        return snipDict
+
+
 def parseCommandLine():
     parser = OptionParser(usage = """
-    %prog [-o FILE] snippet1 snippet2 ...      build Makefile.rules from snippets
+    %prog [-o FILE] top-level-snippet      build Makefile.rules from the top-level-snippet and included ones
     %prog [-o - ] -s Makfile.rules
     """)
     parser.add_option("-s", "--split",
@@ -110,109 +313,77 @@ def parseCommandLine():
                       help="Split given Makefile.rules to the original snippets")
     parser.add_option("-o", "--output",
                       action="store", dest="output", default=False, metavar="RULES",
-                      help="Output built Makefile.rules to file RULES")
+                      help="Write Makefile.rules to file RULES")
     (options, args) = parser.parse_args()
+    if len(args) > 1:
+        parser.print_help()
+        sys.exit(1)
     return options, args
 
-def splitToSnippets(rules):
-    """Split rules to the original snippets. The output is dictinary
-    of lists of lines"""
-
-    snipBegin = re.compile("^(.*)#OMK@(.*)$")
-    snipDict = dict()
-    currentLinesList = None
-
-    for line in rules:
-        match = snipBegin.match(line)
-        if match:
-            line = match.group(1).rstrip() + "\n"
-            snipName = match.group(2)
-            if not snipName in snipDict:
-                snipDict[snipName] = []
-            currentLinesList = snipDict[snipName]
-
-        currentLinesList.append(line);
-    return snipDict
-
-def convertSnipDict(snipDict):
-    """Takes dictionary of snippets, where each snippet is a lists of
-    lines, as the input argument and returns dictionary of snippets objects"""
-    outDict = dict()
-
-    for s in snipDict:
-        snip = Snippet()
-        snip.name = s
-        snip.readLines(snipDict[s])
-        outDict[s] = snip
-    return outDict
-
-def readSnippets(fnames):
-    """Reads the snippets from several files and retuns them as a
-    dictionaly indexed by file name."""
-    snipDict = dict()
-        
-    for fn in fnames:
-        snipDict[fn] = Snippet(fn)
-
-    return snipDict
-
-    
-def combineRules(snippets):
-    """Combine all snippents from the snippets dictionary to one list
-    of lines."""
-
-    rules = list()
-
-    for type in ['legal', 'doc', 'code']:
-        for s in snippets:
-            snip = snippets[s]
-            if len(snip.__dict__[type]) == 0: continue
-            firstLine = string.rstrip(snip.__dict__[type][0])
-            rules.append(firstLine.ljust(60)+" #OMK@%s\n"%snip.name)
-            rules.extend(snip.__dict__[type][1:]);
-    return rules
-
-def assertSameSnippets(d1, d2):
-    theSame = d1==d2
-    if not theSame:
-        # Generate an error message
-        for s in d1:
-            if (d1[s] != d2[s]):
-                sys.stderr.write("Consistency error: ")
-                s1 = d1[s]
-                s2 = d2[s]
-                for i in range(len(s1)):
-                    if s1[i] != s2[i]:
-                        sys.stderr.write("snippet %s, line %d differs!\n")
-                
-    return theSame
+def buildRules(topLevelSnippet, output):
+    rules = MakefileRules()
+    rules.combineFrom(topLevelSnippet)
 
-def buildRules(fnames, output):
-    snipDict = readSnippets(fnames)
-    rules = combineRules(snipDict)
-    snipDict2 = convertSnipDict(splitToSnippets(rules))
+    rulesCheck = MakefileRules()
+    rulesCheck.rules = rules.rules
+    rulesCheck.split()
 
-    if assertSameSnippets(snipDict, snipDict2) == False:
+    if rules.snippets != rulesCheck.snippets:
+        sys.stderr.write("Consistency error:\n")
+        diff = rules.snippets.getDiff(rulesCheck.snippets)
+        sys.stderr.write(diff)
         sys.exit(1)
         
-
-    if output: f = open(output,"w+")
-    else:
-        f = sys.stdout
-
-    f.writelines(rules)
-
+    if output:
+        try: os.makedirs(os.path.dirname(output))
+        except: pass
+        f = open(output,"w+")
+    else: f = sys.stdout
+    f.writelines(rules.rules)
     f.close()
 
 def splitRules(rulesFN, output):
-    pass
+    rules = MakefileRules()
+    rules.rules.loadFromFile(rulesFN)
+    rules.split()
+
+    rulesCheck = MakefileRules()
+    rulesCheck.snippets = rules.snippets
+
+    topLevelSnippet = None
+    for snip in rules.snippets:
+        if snip.name.startswith("Makefile.rules."):
+            topLevelSnippet = snip.name
+    if not topLevelSnippet:
+        sys.stderr.write("No toplevel snippet (Makefile.rules.*) found\n")
+        sys.exit(1)
+        
+    rulesCheck.combineFrom(topLevelSnippet, onlyCheck=True)
+
+    # The comparsion is not that simple. The order of rules might be
+    # different. FIXME: Is this still true?
+#     if rules.rules != rulesCheck.rules:
+#         sys.stderr.write("Consistency error:\n")
+#         diff = rules.rules.getDiff(rulesCheck.rules)
+#         sys.stderr.write(diff)
+#         sys.exit(1)
+
+    for snip in rules.snippets:
+        if snip.name[0:2] == "__":
+            continue
+        print snip.name
+        f = None
+        if output == "-": f = sys.stdout
+        else: f = open(snip.name, "w+")
+        f.writelines(snip.asLinesList())
+        f.close()
 
 def main():
     (options, args) = parseCommandLine()
     if options.split:
         splitRules(options.split, options.output)
     else:
-        buildRules(args, options.output)
+        buildRules(args[0], options.output)
 
 
-if __name__ == "__main__":    main()
+if __name__ == "__main__": main()