More on reg exps. Parsing a C or C++ file with regexps in Python

Ok, so while i'm on the regexp wave. It's plain dumb but works fine. I know i could have used ctags or smth else, but for the sake of it. Also I googled for an example like this one but found nothing. It's always a good idea to have smth like this i case you need to generate prototypes for a long C file or nomatter what.

 #!/usr/bin/env python
 
 import os, re, sys
 
 class Cexploder():
     Body = re.compile("{[^{}]*}", re.DOTALL|re.MULTILINE)
     Func = re.compile("(\w+\s+)*\w+\s*\(.*?\)", re.DOTALL| re.MULTILINE)
     MultiLineComment = re.compile("/\*.*?\*/", re.DOTALL|re.MULTILINE)
     OneLineComment = re.compile("//.*?$", re.DOTALL|re.MULTILINE)
     CppDirectives = re.compile("^\s*#.*?$", re.DOTALL|re.MULTILINE)
     #^\s*#(.*?(\\\n)*)+\n
     
     def __init__(self, File=''):
         f = open(File, 'r')
         self.data = f.read()
         f.close()
 
     def GetPrototypes(self):
         FuncList = []
         pdata = self.data
         pdata = self.OneLineComment.sub('', pdata)
         pdata = self.MultiLineComment.sub('', pdata)
         pdata = self.CppDirectives.sub('', pdata)
 
         while self.Body.search(pdata) != None:
             pdata = self.Body.sub('', pdata)
         
         fiter = self.Func.finditer(pdata)
         for i in fiter:
             FuncList.append( pdata[i.start() : i.end()] )
         
         return FuncList
 
 c = Cexploder(sys.argv[1])
 f = c.GetPrototypes()
 for i in f:
     print i

Regular expressions for fun and profit!

So the year is 2007 the century 21-th, but still there are ppl who deny using regular expressions to do the job. Why? I don't know. May be they just don't know how to do it, may be they think it's slow, or they just never heard of it. But it makes me sick looking at lame pseudo parsers their awkward logic and tons of stupid useless code around for something as simple as digging a file for a pattern. I've seen guys spending a day writing code that can be replaced with just one line using a regular expression, and why? Do they gain something out of this? Performance? Speed? No, they usualy do this for a lame script to automate something and they don't care much if it's gonna take 10mS ot a second. The truth is they realy don't know how much easier it just because they have never done it before.

So for all of them here's a example of a quick and dirty script I used to generate a report. It simply goes through every file in a directory and looks for the following pattern "/*#.*?#*/". It's a bracket structure taken as a comment within C files. It's simple and i use it to write stuff about something that later might end up in a report. Sometimes i write in there something like "See line 1923" or "Line 192" wich ofcourse means a reference to that line, that's why i made my script look for such patterns and if one exists it'll dump it.

So enough goofing around this is the script:

 #!/usr/bin/env python
 
 import os, re, sys
 
 Cover = re.compile("/\*\#.*?\#\*/", re.DOTALL|re.MULTILINE)
 SeeAlso = re.compile("(see|line)+.*?\d+", re.DOTALL|re.MULTILINE|re.IGNORECASE)
 Number = re.compile("\d+")
 
 class Result:
     pass
 
 def GetLinesAround(Data = '', Line = 0, LinesAround = 5):
     ret = ''
     d = Data.split('\n')
     
     if Line >= LinesAround/2:
         upper = Line - LinesAround/2
     else:
         upper = 0;
     
     lower = Line + LinesAround/2 + 1
     if lower > d.__len__():
         lower = d.__len__()
     
     try:
         d = d[upper : lower]
     except Exception: 
         return ret
 
     for s in d:
         ret = ret + str(s) + '\n'
 
     return ret
 
 def GenUtReport(File = '', RelativePath=''):
     f = open(File, 'r')
     data = f.read()
     f.close()
 
     ret = []
     
     utIter = Cover.finditer(data)
     for i in utIter:
         res = Result()
         
         avLine = data[0:i.start()].count('\n') + (data[i.start():i.end()].count('\n')/2)
         
         res.fInfo = "File: " + str(RelativePath) + " Line: " + str(avLine)
         res.utInfo = data[i.start():i.end()].split(':')[1].replace('#*/', '')
         res.codeAroundUt = GetLinesAround(data, avLine)
         
         res.seeAlsoInfo = []
         seeIter = SeeAlso.finditer(res.utInfo)
         for si in seeIter:
             seeLine = Number.findall(res.utInfo[si.start():si.end()])
             if seeLine != None:
                 seeLine = seeLine[0]
                 res.seeAlsoInfo.append( ( seeLine, 10, GetLinesAround(data, int(seeLine), 10) ) )
         
         ret.append(res)
         
     return ret
 
 def PrityPrint(ret = []):
     tmpStr = ''
     
     for res in ret:
         tmpStr = tmpStr + "<tr>"
         tmpStr = tmpStr + "<td>" + res.fInfo + "</td>"
         tmpStr = tmpStr + "<td>" + res.utInfo  + "</td>"
         tmpStr = tmpStr + "<td>" + res.codeAroundUt + "</td>"
         tmpStr = tmpStr + "<td>"        
         for i in res.seeAlsoInfo:
             tmpStr = tmpStr + "See Also. Code around LINE: " + i[0] + " (+/-)"+ str(i[1]/2) +"\n\n"+ str(i[2])
         tmpStr = tmpStr + "</td>"
         tmpStr = tmpStr + "</tr>"
     
     return tmpStr.replace('\n', '<br>')
 
 tmpStr = """<html><head></head><body><table border="1">
 <tr>
 <td><b>Filename, Line number</b></td>
 <td><b>UT not covered reason</b></td>
 <td><b>Related code</b></td>
 <td><b>See also</b></td>
 </tr>"""
 
 for r, d, f in os.walk(sys.argv[1]):
     for file in f:
         tmpStr = tmpStr + PrityPrint(GenUtReport( os.path.join(r, file) , file))
 
 tmpStr = tmpStr + "</table></body></html>"
 print tmpStr

So you see in less than 100 lines I did it all. Parsing, referencing, generating a report in html. It took me less than 2 hours to finish this.