umake_pb.py

linux下的一款播放器

    ##                 for f in os.listdir(h):
    ##                     potential_headers.append(os.path.join(h,f))
    ##             else:
    ##                 if string.lower(os.path.splitext(h)[1]) == ".h":
    ##                     h=os.path.normpath(h)
    ##                     self.add_header(h)


            for dir in project.includes:
                c=os.getcwd()
                fd=os.path.normpath(os.path.join(c,dir))
                if fd[:len(c)] != c:
                    continue
                if os.path.isdir(dir):
                    for f in os.listdir(dir):
                        h=os.path.join(dir,f)
                        if string.lower(os.path.splitext(h)[1]) == ".h":
                            h=os.path.normpath(h)
                            self.add_header(h)

            for h in project.public_headers:
                self.add_header(h, [ "Public" ])

            for h in project.private_headers:
                self.add_header(h, [ "Private" ])

            libsearchpaths=[]

            if project.target_type  != "lib":
                for fw in project.sys_frameworks:
                    self.framework_phase.files.append(PBXBuildFile(
                        self.pb.add_framework(fw)))

                for lib in string.split(makefile.expand_variables("$(STATIC_LIBS)",tmp_vars)):
                    self.framework_phase.files.append(PBXBuildFile(
                        self.pb.add_library(lib)))

                    if os.path.exists(lib):
                        global ranlib_cache
                        abslib=os.path.normpath(os.path.join(os.getcwd(), lib))
                        while os.path.islink(abslib):
                            abslib=os.path.normpath(os.path.join(
                                os.path.dirname(abslib),
                                os.readlink(abslib)))
                        if not ranlib_cache.has_key(abslib):
                            ranlib_cache[abslib]=1
                            print 'Running ranlib "%s"' % abslib
                            status, output = shell.run('ranlib "%s"' % abslib)
                            print output
                            if status:
                                raise "RANLIB on '%s' failed with error=%d" % (lib, status)

                    path = os.path.dirname(lib)
                    if path not in libsearchpaths:
                        libsearchpaths.append(path)


            for lib in project.libraries:
                self.framework_phase.files.append(PBXBuildFile(
                    self.pb.add_library(lib)))

            settings["LIBRARY_SEARCH_PATHS"]=string.join(libsearchpaths)

            ## Import/override project.preferences
            for key in project.preferences.keys():
                if type(project.preferences[key]) == types.StringType:
                    settings[key]=project.preferences[key]

            name = os.path.join(self.project.module_directory(),
                                self.project.makefile_name)
            name = umake_lib.declaw_name(name)

            ## Get the productSettingsXML from an (option) variable in
            ## in the project object.
            if project.target_type  != "lib":
                try:
                    xmltmp = project.productSettingsXML
                    xmltmp=string.replace(xmltmp,"_NAME_",project.target_name);
                    vfile=project.target_name
                    try:
                        vfile=project.version_file
                    except:
                        pass

                    version=('0','0','0','0')
                    try:
                        version = platform.versioning.get_version(vfile,"")
                    except err.error, e:
                        print "Umake warning: Failed to find version file. (%s)" % vfile

                    xmltmp=string.replace(xmltmp,"_VERSION_",string.join(version,"."))
                    xmltmp=string.replace(xmltmp,"_VER_", string.join(version[:-1],"."))
                    xmltmp=string.replace(xmltmp,"_BUILD_", str(version[-1]))
                    xmltmp=string.replace(xmltmp,"_ORIGINATOR_",project.bundle_originator);

                    ## PB-do, but doesn't seem to harm Xcode
                    target.productSettingsXML = xmltmp

                    ## Xcode-do, but shouldn't harm PB
                    defdir = self.project.output_dir
                    shell.mkdir(defdir)
                    n = os.path.join(self.project.module_directory(),
                                     self.project.makefile_name)
                    plist_file_name = umake_lib.declaw_name(n)+"_info.plist"
                    plist_file_name=os.path.join(defdir, plist_file_name)
                    umake_lib.write_file(plist_file_name, xmltmp)
                    settings["INFOPLIST_FILE"]=plist_file_name

                except KeyError:
                    pass

            ## Should be last!
            base=os.path.basename(project.output_path()[0])

            #if project.target_type  == "lib":
            #    ranlib='ranlib -s "build/%s" ; ' % base
            #else:
            #    ranlib=""

            if self.project.target_type == "dll" and debug != "YES":
                ## Build an export function table, hope this
                ## Does everything we need

                expdir = self.project.output_dir
                shell.mkdir(expdir)
                expfile = os.path.join(self.project.module_directory(),
                                       self.project.makefile_name)
                expfile = umake_lib.declaw_name(expfile)+".exp"
                expfile=os.path.join(expdir, expfile)

                contents=string.join(self.project.exported_func,"\n_")
                if contents:
                    contents="_%s\n" % contents

                umake_lib.write_file(expfile,contents);

                fname=base[:-7] ## Remove ".bundle"
                strip_phase=PBXShellScriptBuildPhase(
                    'if [ -f "build/%s/Contents/MacOS/%s" ] ; then strip -u -s "%s" "build/%s/Contents/MacOS/%s"; fi ' % \
                    (base,fname, expfile,base,fname))

                target.buildPhases.append(strip_phase)

            script_phase=PBXShellScriptBuildPhase(
                'test -e "$RIBOSOME_OUTPUT_DIR/%s" && %s "$RIBOSOME_OUTPUT_DIR/%s" ; %s "build/%s" "$RIBOSOME_OUTPUT_DIR" ' %
                (base,
                 platform.rm.cmd,
                 base,
                 platform.copy.cmd,
                 base))

            target.buildPhases.append(script_phase)

            ## This creates a named symlink to the target
            odir=self.project.output_dir
            shell.mkdir(odir)
            bas,ext=os.path.splitext(base)
            linkname="%s/%s__%s%s" % (
                odir,
                bas,
                string.replace(project.module_directory(),"/","_"),
                ext)

            if not os.path.exists(linkname) and not os.path.islink(linkname):
                os.symlink(base, linkname)

            ## End of lib/exe/dll target code

        ## Extra shellscriptphases
        tmp=[]
        for cmd in project.pre_build_commands:
            tmp.append(PBXShellScriptBuildPhase(cmd))

        target.buildPhases=tmp + target.buildPhases

        for cmd in project.post_build_commands:
            target.buildPhases.append(PBXShellScriptBuildPhase(cmd))

        pb.quicksave(name)


    def add_source_file(self, file):
        ret=PBXBuildFile(self.pb.add_source_file(file))
        self.source_phase.files.append(ret)
        return ret

    def add_dep(self, pb_target):
        self.target.dependencies.append(pb_target.target)



class pb_makefile_generator(umake_makefile.makefile_generator):

    ## This only generates a call to pbxbuild
    def MainTarget(self):
        if self.project.target_type == "":
            return

        output_path, output_name = self.project.output_path()
        
        self.AllTarget( "build" )

        name = os.path.join(self.project.module_directory(),
                            self.project.makefile_name)
        name = umake_lib.declaw_name(name)

        self.writeln(".PHONY:")
        self.writeln("")

        self.writeln("build: .PHONY")
        if objectVersion == 38:
            self.writeln('\tpbxbuild -target "%s"' % name)
        else:
            self.writeln('\txcodebuild -target "%s"' % name)

        ## for DRM signing
        if self.project.target_type == "dll" and \
               self.project.BuildOption("drmsign") and \
               self.project.CheckDRMSign():
            try:
                temp = os.path.join(os.environ["BUILD_ROOT"], "bin", "drmsign")
            except KeyError:
                temp = "drmsign"
            
            self.writeln("\t%s %s" % (temp, output_path))

        self.writeln('')
        
        self.CleanTarget()
        self.CopyTarget()
        self.DependTarget()

    ## Dummy dependtarget
    def DependTarget(self):
        if self.created_targets.has_key("depend"):
            return
        self.created_targets["depend"]=1
        
        self.writeln("depend:")
        self.writeln("")


    def CleanTarget(self, targets = ""):
        """Make clean"""
        if self.created_targets.has_key("clean"):
            return
        self.created_targets["clean"]=1

        name = os.path.join(self.project.module_directory(),
                            self.project.makefile_name)
        name = umake_lib.declaw_name(name)

        self.writeln("clean:")
        if objectVersion == 38:
            self.writeln('\tpbxbuild -target "%s" clean' % name)
        else:
            self.writeln('\txcodebuild -target "%s" clean' % name)

        self.call_all_submake("clean", 1)
        self.writeln('')


class uber_generator(umake_lib.Targets):

    def __init__(self, platform, project):
        umake_lib.Targets.__init__(self, platform, project)

        uberdata = []
        for sumake in project.get_uber_makes():
            uberdata.append(  {
                "name":umake_lib.declaw_name(sumake.abs_makefile()),
                "abs_makefile":sumake.abs_makefile(),
                "makefile":sumake.makefile(),
                "dependencies":sumake.dependencies(),
                })
                

        name = os.path.join(self.project.module_directory(),
                            self.project.makefile_name)
        name = umake_lib.declaw_name(name)
        marshal.dump(uberdata, open(name+"-uberdata","w"))


class update_project(umake_lib.Targets):
    
    def __init__(self, platform, project):
        umake_lib.Targets.__init__(self, platform, project)

        pb=projectbuilder()

        all=PBXAggregateTarget("All")
        pb.pbx.targets.append(all)

        uberdata=[]
        uberdata_done={}
        local_targets={}
        
        for p in os.listdir("."):
            if p[-6:] == "-pbtmp":
                path=p[:-6]
                at=pb.AddProject_nofix(path)
                key=os.path.normpath(os.path.join(os.getcwd(), path));
                local_targets[key]=at
        
            if p[-9:] == "-uberdata":
                for sumake in marshal.load(open(p)):
                    if not uberdata_done.has_key(sumake["name"]):
                        uberdata_done[sumake["name"]]=1
                        uberdata.append(sumake)
                        
                    
        targets={}
        for sumake in uberdata:
            name=umake_lib.declaw_name(sumake["abs_makefile"])
            path = os.path.dirname(sumake["makefile"])
            path = os.path.join(path, umake_lib.declaw_name(sumake["abs_makefile"]))
            key=os.path.normpath(os.path.join(os.getcwd(), path));
                
            if local_targets.has_key(key):
                at=pb.CopyTargets(local_targets[key], "_uber")
            else:
                at=pb.AddProject(path,"_uber")
                
            targets[name] = at
            for t in at:
                all.dependencies.append(PBXTargetDependency(t,pb.pbx))

        ## This could be a little more abstract...
        for sumake in uberdata:
            name=umake_lib.declaw_name(sumake["abs_makefile"])
            ax=targets[name]
            for dep in sumake["dependencies"]:
                dep=umake_lib.declaw_name(dep)
                if targets.has_key(dep):
                    ay=targets[dep]
                    for x in ax:
                        for y in ay:
                            x.dependencies.append(PBXTargetDependency(y,
                                                                      pb.pbx))
                else:
                    print "UMAKE WARNING: Unable to resolv dependency %s" % dep


        pb.save("Project")


def make_makefile(platform, project):
    
    #if os.path.islink("build"):  # Uncomment this later for more security
    #    shell.rm("build")
    #if not os.path.exists("build"):
    #    os.symlink(project.output_dir, "build")
    #
    #if not os.path.exists("..."):
    #    os.symlink(".", "...")
    #
    #if not os.path.exists("build/..."):
    #    os.symlink("..", "build/...")


    project_generator(platform, project)
    uber_generator(platform, project)
    update_project(platform, project)


if __name__ == '__main__':
    import sys

    c=codec()
    #print c
    f=sys.stdin.read()
    d=c.unconvert(f)
    #print d
    print c.prettyprint(d)
    #print c.convert(d)