File indexing completed on 2024-05-12 16:39:34

 #!/usr/bin/python -Qwarnall
 
 #
 # This script fixes trivial errors in the sources:
 #  - Add a newline to files that don't end in one. (only apply to source files!)
 #  - Normalize SIGNAL and SLOT signatures
 #  - Improve #include status: remove duplicates
 #  - ...more later
 #
 
 import sys
 import os
 import string
 import getopt
 import re
 import fnmatch
 
 
 # Global variables
 dryrun = False    # Maybe the default should be True...
 pattern = "*"
 recursive = False
 verbose = False
 
 
 # ----------------------------------------------------------------
 #                         Individual actions
 
 
 def doIncludes(contents):
     global verbose
     global dryrun
 
     # Compile a regex that matches an include statement.
     # We do no syntax check so    #include "foo> is found by this.
     includePattern = '^(\\#include\\s*)(["<])([^">]+)([">])(.*)'
     includeRegex = re.compile(includePattern)
 
     lineNo = 1
     newContents = []
     foundIncludes = []
     for line in contents:
         #print "input: ", line
 
         # See if this line is an include line.  If not, just append it
         # to the output and continue.
         includes = includeRegex.findall(line)
         #print "includes: ", includes
         if len(includes) == 0:
             newContents.append(line)
             lineNo = lineNo + 1
             continue
 
         include = includes[0]
         # Here we know it's an include statement.  We should only have found one hit.
         #  include[0] = "#include "
         #  include[1] = "\"" or "<"
         #  include[2] = the filename in the include statement
         #  include[3] = "\"" or ">"
         #  include[4] = the rest of the line
         includeName = include[2]
         #print "include name: ", includeName
         
         if includeName in foundIncludes:
             if verbose:
                 sys.stderr.write("  Duplicate include on line " + str(lineNo) + " (removing)\n")
         else:
             foundIncludes.append(includeName)
             newContents.append(line)
 
         lineNo = lineNo + 1
 
     return newContents
 
 
 def doNormalize(contents):
     global verbose
 
     # Compile a regex that matches SIGNAL or SLOT followed by two
     # parenthesis levels (signal/slot + function)
     #
     # Warning: This is a very simple parser that will fail on multi-line
     #          cases or cases with more than 2 parenthesis.  But it should
     #          cover the majority of cases.
     topPattern = "(SIGNAL|SLOT)(\\s*\\([^\\(]*\\([^\\)]*\\)\s*\\))"
     topRegex = re.compile(topPattern)
 
     # regex to identify the parameter list
     #   [0]: Start parenthesis
     #   [1]: the identifier (function name of the signal or slot)
     #   [2]: the parameter list
     #   [3]: end parenthesis
     # Note: this won't work on function parameters with their own parameter list.
     paramPattern = "(\s*\\(\s*)([a-zA-z][a-zA-z0-9]*)(\s*\\(\s*[^\\)]*\s*\\))(\s*\\)\s*)"
     paramRegex = re.compile(paramPattern)
 
     lineNo = 1
     newContents = []
     for line in contents:
         #print "input: ", line
 
         # Replace signal/slot signatures with the normalized equivalent.
         signalSlotMacros = topRegex.findall(line)
         for macro in signalSlotMacros:
             # Parameters to SIGNAL or SLOT
             signalSlotParam = macro[1] #macro[0] = "SIGNAL" or "SLOT"
 
             params = paramRegex.findall(signalSlotParam)
             if not params:
                 continue
             params = params[0]  # There should only be one hit
             #print "params:", params, len(params)
 
             functionName  = params[1]
             paramList = params[2].strip()[1:-1]  # remove the parenthesis
             #print repr(functionName), repr(paramList)
 
             # Now we have dug out the parameter list to the function
             # This sequence does the actual normalizing.
             functionParams = paramList.split(",")
             #print functionParams
             outParamList = []
             for functionParam in functionParams:
                 s = functionParam.strip()
                 if s[:5] == "const" and s[-1:] == "&":
                     # Remove const-&
                     outParamList.append(s[5:-1].replace(" ", ""))
                 elif s[:5] == "const" and s[-1:] == "*":
                     # Do NOT remove const for pointers. Just remove spaces.
                     outParamList.append("const " + s[6:].replace(" ", ""))
                 elif s[:5] == "const":
                     # Remove const without & or *
                     outParamList.append(s[5:].replace(" ", ""))
                 elif s[-1:] == "&":
                     # Keep & without const but remove spaces
                     outParamList.append(s.replace(" ", ""))
                 else:
                     # Keep parameter without any const and & but remove spaces
                     # (This and the last line could be combined.)
                     outParamList.append(s.replace(" ", ""))
             outParams = string.join(outParamList, ",")
             signalSlotParam2 = "(" + functionName + "(" + outParams + "))"
 
             if verbose and signalSlotParam != signalSlotParam2:
                 sys.stderr.write("  Normalizing " + macro[0] + " statement on line "
                                  + str(lineNo) + "\n")
 
             line = line.replace(signalSlotParam, signalSlotParam2, 1)
             #print "result: ", line
 
         # When we exit the loop all the substitutions inside the line are done.
         newContents.append(line)
         lineNo = lineNo + 1
 
     return newContents
 
 
 # ----------------------------------------------------------------
 
 
 def handleFile(name, actions):
     global dryrun, verbose
 
     if verbose:
         sys.stderr.write(name + ":\n")
 
     # Read the contents of the file into a list, one item per line.
     infile = open(name)
     contents = infile.readlines()
     infile.close()
 
     if "endswitheol" in actions:
         if contents != [] and contents[-1] != "" and contents[-1][-1] != "\n":
             if verbose:
                 sys.stderr.write("  Adding EOL to end of file\n")
             contents[-1] = contents[-1] + "\n"
     if "normalize" in actions:
         contents = doNormalize(contents)
     if "includes" in actions:
         contents = doIncludes(contents)
 
     if not dryrun:
         outname = name + "--temp"  #FIXME: Generate real tempname
         outfile = open(outname, "w")
         outfile.writelines(contents)
         outfile.close()
         os.rename(outname, name)
 
 
 def traverseTree(dir, actions, names):
     global recursive, verbose, pattern
 
     # We could also use os.walk()
     for name in names:
         if dir == "":
             fullname = name
         else:
             fullname = dir + "/" + name
 
         if not os.path.exists(fullname):
             sys.stderr.write(fullname + ": unknown file or directory\n")
             continue
 
         if os.path.isdir(fullname):
             if recursive:
                 traverseTree(fullname, actions, os.listdir(fullname))
             # Ignore all directories if not in recursive mode
         else:
             if fnmatch.fnmatch(name, pattern):
                 handleFile(fullname, actions)
 
 
 # ================================================================
 
 
 def usage(errormsg=""):
     if errormsg:
         print "Error:", sys.argv[0] + ":", errormsg, "\n"
     else:
         print "Fix trivial errors in the source tree.\n"
 
     print """usage: fixsrc.py [options] [files]
     options:
         -a --actions    a comma separated list of the following possible actions:
                           endswitheol:  adds newline at the end to files that don't end in newline
                           normalize:    normalizes SIGNAL and SLOT signatures
                           includes:     improves #include status (currently: removes duplicates)
                           all:          all of the above
         -d --dryrun     don't actually perform the actions (combine with --verbose)
                         This is recommended before doing the full run.
         -h --help       print this help and exit immediately
         -p --pattern    apply to files whose name matches a certain glob pattern
         -r --recursive  recursive: all files that are directories are traversed recursively
         -v --verbose    print extra verbose output
 
     files:
         source files to be fixed and/or directories if --recursive is given
 
     examples:
         fixsrc.py -rv --actions endswitheol libs
         fixsrc.py -rv --pattern '*.cpp' --actions normalize .
 """
     sys.exit(0)
 
 
 def main():
     global dryrun, recursive, pattern, verbose
     allActions = ["endswitheol", "normalize", "includes", "all"]
 
     try :
         opts, params = getopt.getopt(sys.argv[1:], "a:dhp:rv" ,
                                      ["actions=", "dryrun", "help", "pattern=", "recursive", "verbose"])
     except getopt.GetoptError:
         usage("unknown options")
     #print "opts:", opts
     #print "params:", params
 
     actions = []
     for opt, param in opts:
         #print opt, param
         if opt in ("-a" , "--actions"):
             actions = string.split(param, ",")
             #print "actions: ", actions
             for a in actions:
                 if not a in allActions:
                     usage("unknown action: " + a + "\n\n")
             if "all" in actions:
                 actions = allActions[:-1] # Remove "all", which is a meta action.
                 
         elif opt in ("-d" , "--dryrun"):
             dryrun = True
         elif opt in ("-h" , "--help"):
             usage()
         elif opt in ("-p" , "--pattern"):
             pattern = param
         elif opt in ("-r" , "--recursive"):
             recursive = True
         elif opt in ("-v" , "--verbose"):
             verbose = True
 
     if actions == []:
         usage("no actions defined")
 
     # Do the actual work
     traverseTree("", actions, params)
 
     return 0
 
 if __name__ == '__main__':
     main()