umakepp.py

linux下的一款播放器

def rpl_local_libs(m):
    return "project.AddLocalLibraries(%s)" % (m.group(2))
def rpl_system_paths(m):
    return "project.AddSystemPaths(%s)" % (m.group(2))
def rpl_exported_func(m):
    return "project.AddExportedFunctions(%s)" % (m.group(2))

def rpl_BuildProgramTarget(m):
    return "ProgramTarget(%s)" % (m.group(2))
def rpl_NormalLibraryTarget(m):
    return "LibraryTarget(%s)" % (m.group(2))


## regular-expression generateors
def project_re1(attr):
    return "(project\.%s\s*\[[^:]*:[^\]]*\]\s*=\s*\[(.*)\]$)" % (attr)

def project_re2(attr):
    return "(project\.%s\.append\((.*)\)$)" % (attr)

def project_re3(attr):
    return "(project\.%s\s*=\s*\[(.*)\]$)" % (attr)

def project_re4(attr):
    return "(project\.%s\s*=\s*project\.%s\s*\+\s*\[(.*)\]$)" % (attr, attr)

_rpl_list = [
    (re.compile("^(\s*)(print\s+.*)"), rpl_print),

    (re.compile("(project\.target_name\s*=\s*(.*))"), rpl_target_name),
    
    (re.compile("(project\.target_type\s*=[^=])"), rpl_pass),
    (re.compile("(project\.object_dir\s*=[^=])"), rpl_pass),
    (re.compile("(project\.output_dir\s*=[^=])"), rpl_pass),
    (re.compile("(project\.dll_type\s*=[^=])"), rpl_pass),
    (re.compile("(project\.src_root_path\s*=[^=])"), rpl_pass),
    (re.compile("(project\.target_dir\s*=[^=])"), rpl_pass),
    (re.compile("(project\.module_dir\s*=[^=])"), rpl_pass),
    (re.compile("(project\.project_dir\s*=[^=])"), rpl_pass),
    (re.compile("(project\.makefile_path\s*=[^=])"), rpl_pass),

    (re.compile("(platform\.lib_subdir\s*=[^=])"), rpl_pass),
    (re.compile("(platform\.lib_subdir)"), rpl_lib_subdir),
    
    (re.compile("(SetupDefines\(\))"), rpl_pass),
    (re.compile("(CPPSuffixRule\(\))"), rpl_pass),
    (re.compile("(SetupTargetDir\(\))"), rpl_pass),
    (re.compile("(DependTarget\(\))"), rpl_pass),
    (re.compile("(ResourceOnlyDLLTarget\(.*\))"), rpl_pass),
    (re.compile("(EmptyTargets\(\))"), rpl_EmptyTarget),
    (re.compile("(SimpleEmptyRules\(\))"), rpl_EmptyTarget),
    
    (re.compile(project_re1("defines")), rpl_defines),
    (re.compile(project_re2("defines")), rpl_defines),
    (re.compile(project_re3("defines")), rpl_defines),
    (re.compile(project_re4("defines")), rpl_defines),
    
    (re.compile(project_re1("sources")), rpl_sources),
    (re.compile(project_re2("sources")), rpl_sources),
    (re.compile(project_re4("sources")), rpl_sources),
    
    (re.compile(project_re1("objsrcs")), rpl_objsrcs),
    (re.compile(project_re2("objsrcs")), rpl_objsrcs),
    (re.compile(project_re4("objsrcs")), rpl_objsrcs),
    
    (re.compile(project_re1("includes")), rpl_includes),
    (re.compile(project_re2("includes")), rpl_includes),
    (re.compile(project_re4("includes")), rpl_includes),

    (re.compile(project_re1("libraries")), rpl_libraries),
    (re.compile(project_re2("libraries")), rpl_libraries),
    (re.compile(project_re4("libraries")), rpl_libraries),

    (re.compile(project_re1("libraries2")), rpl_libraries2),
    (re.compile(project_re2("libraries2")), rpl_libraries2),
    (re.compile(project_re4("libraries2")), rpl_libraries2),

    (re.compile(project_re1("sys_libraries")), rpl_sys_libraries),
    (re.compile(project_re2("sys_libraries")), rpl_sys_libraries),
    (re.compile(project_re4("sys_libraries")), rpl_sys_libraries),

    (re.compile(project_re1("dynamic_libraries")), rpl_dynamic_libraries),
    (re.compile(project_re2("dynamic_libraries")), rpl_dynamic_libraries),
    (re.compile(project_re4("dynamic_libraries")), rpl_dynamic_libraries),

    (re.compile(project_re1("module_libs")), rpl_module_libs),
    (re.compile(project_re2("module_libs")), rpl_module_libs),
    (re.compile(project_re4("module_libs")), rpl_module_libs),

    (re.compile(project_re1("local_libs")), rpl_local_libs),
    (re.compile(project_re2("local_libs")), rpl_local_libs),
    (re.compile(project_re4("local_libs")), rpl_local_libs),

    (re.compile(project_re1("system_paths")), rpl_system_paths),
    (re.compile(project_re2("system_paths")), rpl_system_paths),
    (re.compile(project_re4("system_paths")), rpl_system_paths),

    (re.compile(project_re1("exported_func")), rpl_exported_func),
    (re.compile(project_re2("exported_func")), rpl_exported_func),
    (re.compile(project_re4("exported_func")), rpl_exported_func),

    (re.compile("(BuildProgramTarget\s*\(\s*([^,]+),.*\))"),
     rpl_BuildProgramTarget),
    (re.compile("(NormalLibraryTarget\s*\(\s*([^,]+),.*\))"),
     rpl_NormalLibraryTarget),
    ]


def translate(_line_list):
    """This is the main code morphing function.  It takes a line list with
    exactly one Python statment per line, and compares it aginst a series
    of regular expressions.  It then converts it as necessary, and returns
    a new list of lines of morphed Umakefil code."""

    line_list = []

    for line in _line_list:

        ## fast-skip blank lines and comments
        if len(line) == 0 or string.lstrip(line)[0] == "#":
            line_list.append(line)
            continue

        ## run through the replacment list
        did_sub = 0
        for (r, f) in _rpl_list:
            (nl, n) = r.subn(f, line)

            if not n:
                continue

            line_list.append(nl)
            did_sub = 1
            break

        if not did_sub:
            line_list.append(line)

    return line_list

class UMPreProcessor:
    """Takes a list of Umakefil/*.pcf files and pre-processes them."""

    def __init__(self, path):
        """The argument, path, is the path of the output pre-processed
        Umakefil."""
        
        self.path = path
        self.path_list = []
        #self.mtime = 0

    def add_file_list(self, file_list):
        """The argument, file_list, is a list of Umakefil/*.pcf files to
        be combined, and pre-processed in order.  Added files which do
        not exist are ignored."""
        
        for path in file_list:
            if os.path.isfile(path):
                self.path_list.append(path)
                #self.mtime = max(self.mtime, umake_lib.mtime(path))

    def write_umakefil(self, line_list):
        """Given a list of lines, write out the pre-processed Umakefil to
        the output path."""

        # Disabled. This was originally intended to allow umake to
        # run only when needed, but too many external variable affect
        # how umake works to reliably detect when it needs to be re-run.
        # I suppose I better concentrate on making umake faster insead.
        #   -Hubbe
        #
        #upptime = umake_lib.mtime(self.path)
        #
        #if upptime > self.mtime:
        #    return upptime

        if os.path.exists(self.path):
            os.unlink(self.path)
    
        fil = open(self.path, "w")

        fil.write("### UMAKE PRE-PROCESSOR OUTPUT: DO NOT CHECK INTO CVS\n")
        fil.write("### -*- Mode: Python -*-\n")
        fil.write("### files: %s\n" % (string.join(self.path_list, " -> ")))
        fil.write("\n")

        for line in line_list:
            fil.write("%s\n" % (line))

        fil.write("\n")
        fil.write("### END UMAKE PRE-PROCESSOR OUTPUT\n")
        fil.close()

        return 0

    def preprocess(self):
        """Read all the added Umakefil/*.pcf files, pre-process them, and
        return a list of the lines of the pre-processed Umakefil."""
        
        pre_lines = []
        post_lines = []

        ## get the .pcf files
        for path in self.path_list:
            tmp = remove_line_continuations(open(path, "r").read() + "\n", path)
            try:
                i = tmp.index("<insert>")
                pre_lines = pre_lines + tmp[:i]
                post_lines = tmp[i+1:] + post_lines
            except ValueError:
                pre_lines = pre_lines + tmp

        ## many pre-processor filters
        line_list = translate(pre_lines + post_lines)

        return line_list

    def write(self):
        """Pre-process and write out the pre-processed Umakefil."""
        
        line_list = self.preprocess()
        return self.write_umakefil(line_list)


def main():
    import sys
    
    try:
        path_list = sys.argv[1:]
    except IndexError:
        print "give path dummy"
        sys.exit(1)

    umpp = UMPreProcessor("bla")
    umpp.add_file_list(path_list)
    
    for line in umpp.preprocess():
        print line


if __name__ == "__main__":
    main()