umake_pb.py

linux下的一款播放器

        if contents != data:
            open(file,"w").write(data)

        #marshal.dump(sdata, open(name+"-pbtmp","w"))

        #print "Saving:\n"
        #print codec().prettyprint(self.pbx)

        #print "Result:\n"
        #print codec().prettyprint(codec().unconvert(open(dirname+"/project.pbxproj").read()))


    def fix_rel_path(self, f, all=1, dir=None):
        if os.path.isabs(f):
            return f

        n=os.path.join(dir, f)
        n=os.path.normpath(n)
        if all:
            return n

        if f[0] == '-':
            return f;

        ## Ugly
        if not os.path.exists(n):
            return f

        return n

    def fix_rel_paths(self, paths, all=1, dir=None):
        ret=[]
        for path in string.split(paths):
            ret.append(self.fix_rel_path(path, all, dir))
        return string.join(ret)

    def fix_setting(self, t, y, all=1, dir=None):
        if t.buildSettings.has_key(y):
            t.buildSettings[y]=self.fix_rel_paths(t.buildSettings[y], all, dir)

    def AddProject_nofix(self, filename):
        if not os.path.exists(filename+"-pbtmp"):
            print "UMAKE WARNING: Unable to read %s" % (filename+"-pbtmp")
            return []

        data=marshal.load(open(filename+"-pbtmp"))
        x=codec().unconvert(data)

        self.pbx.targets.extend(x.targets)

        for group in x.mainGroup.children:
            self.pbx.mainGroup.children.append(group)

        return x.targets


    def AddProject(self, filename, suffix=""):
        if not os.path.exists(filename+"-pbtmp"):
            print "UMAKE WARNING: Unable to read %s" % (filename+"-pbtmp")
            return []

        data=marshal.load(open(filename+"-pbtmp"))
        x=codec().unconvert(data)

        dir=os.path.dirname(filename)

        for t in x.targets:
            t.name = t.name + suffix
            
            self.fix_setting(t, "OTHER_LDFLAGS", 0, dir)
            self.fix_setting(t, "PREFIX_HEADER", 0, dir)
            self.fix_setting(t, "OBJROOT", 0, dir)
            self.fix_setting(t, "DSTROOT", 0, dir)
            self.fix_setting(t, "SYMROOT", 0, dir)
            self.fix_setting(t, "TEMP_DIR", 0, dir)
            self.fix_setting(t, "HEADER_SEARCH_PATHS", 0, dir)
            self.fix_setting(t, "LIBRARY_SEARCH_PATHS", 0, dir)
            self.fix_setting(t, "FRAMEWORK_SEARCH_PATHS", 0, dir)
            self.fix_setting(t, "RIBOSOME_OUTPUT_DIR", 0, dir)
            self.fix_setting(t, "DEPLOYMENT_LOCATION", 0, dir)
            self.fix_setting(t, "INFOPLIST_FILE", 0, dir)
            self.fix_setting(t, "EXPORTED_SYMBOLS_FILE", 0, dir)

            #p=os.path.join("...",dir,"build",t.productName)
            #p=os.path.normpath(p)
            #t.productName = p
            #t.buildSettings["PRODUCT_NAME"] = p
            #t.productReference.path = p
           
            
        self.pbx.targets.extend(x.targets)

        for group in x.mainGroup.children:
            group.set_path(dir)
            self.pbx.mainGroup.children.append(group)

        return x.targets

    def CopyTargets(self, targets, suffix=""):
        ret = []
        for t in targets:
            t=t.copy()
            t.name=t.name+suffix
            ret.append(t)

        self.pbx.targets.extend(ret)

        return ret;

ranlib_cache={}

class project_generator(umake_lib.Targets):


    def add_header(self, header, attribs = None):
        if self.header_cache.has_key(header):
            bf=self.header_cache[header]
        else:
            bf=PBXBuildFile(self.pb.add_source_file(header,"Headers"))
            self.header_phase.files.append(bf)
            self.header_cache[header]=bf

        if attribs:
            if not bf.settings.has_key("ATTRIBUTES"):
                bf.settings = { "ATTRIBUTES" : attribs }
            else:
                for a in attribs:
                    if a not in bf.settings["ATTRIBUTES"]:
                        bf.settings["ATTRIBUTES"].append(a)

    def __init__(self, platform, project):
        self.header_cache = {}
        
        umake_lib.Targets.__init__(self, platform, project)

        pb=projectbuilder()
        self.pb=pb
        settings = {}
        
        name = os.path.join(self.project.module_directory(),
                            self.project.makefile_name)
        name = umake_lib.declaw_name(name)
        pb.basename=name


        if project.target_type == "":
            target=PBXLegacyTarget(project.makefile_name)
            target.buildArgumentsString='-f "%s" $ACTION'%project.makefile_name
            self.target=target
            pb.pbx.targets.append(target)

            ## Call the standard UNIX makefile generator here..
            umake_makefile.makefile_generator(platform, project)
        else:

            ## Call makefile generator here, we can use the variables
            ## to set up the C compiler and other stuff
            mf_generator = pb_makefile_generator(platform, project)
            mf=mf_generator.mfile

            output_path, output_name = self.project.output_path()

            if project.target_type == "exe":
                output_name=os.path.splitext(output_name)[0]
                target=PBXApplicationTarget(name)
                target.productReference=pb.add_application(output_name,"Products")

            elif project.target_type  == "lib":
                if objectVersion > 38:
                    output_name = output_name[3:-2]
                target=PBXLibraryTarget(name)
                target.productReference=pb.add_library(output_name,
                                                       "Products")
                settings["LIBRARY_STYLE"]="STATIC"

            elif project.target_type  == "dll":
                output_name=os.path.splitext(output_name)[0]
                if project.create_framework:
                    target=PBXFrameworkTarget(name)
                    target.productReference=pb.add_framework(output_name,
                                                             "Products")
                else:
                    target=PBXBundleTarget(name)
                    target.productReference=pb.add_bundle(output_name,
                                                      "Products")
                    if objectVersion == 38:
                        settings["LIBRARY_STYLE"]="Bundle"
                        settings["WRAPPER_EXTENSION"]="bundle"

            else:
                return
            
            ## Output relative file
            #full_name = os.path.join("..", project.output_dir, output_name)
            full_name = output_name
            target.productReference.refType=3
            target.productName = full_name

            if objectVersion > 38:
                target.sourceTree = "BUILT_PRODUCTS_DIR"
                target.includeInIndex = 0
                
            settings["PRODUCT_NAME"] = full_name
            target.productReference.path = full_name

            self.header_phase = PBXHeadersBuildPhase()
            self.resource_phase = PBXResourcesBuildPhase()
            self.source_phase = PBXSourcesBuildPhase()
            self.framework_phase = PBXFrameworksBuildPhase()
            self.rez_phase = PBXRezBuildPhase()

            target.buildPhases.extend( [
                self.header_phase,
                self.resource_phase,
                self.source_phase,
                self.framework_phase,
                self.rez_phase,
                ])

            self.target=target
            pb.pbx.targets.append(target)

            settings["OTHER_LDFLAGS"] = ""
            settings["OTHER_REZFLAGS"] = ""
            if objectVersion == 38:
                settings["DEBUG_SYMBOLS"]="NO"
            else:
                settings["GCC_GENERATE_DEBUGGING_SYMBOLS"]="NO"
            #settings["SYMROOT"]=project.output_dir
            #settings["OBJROOT"]=os.path.join(project.output_dir,"obj")
            #settings["TEMP_DIR"]=os.path.join(project.output_dir,"obj",name)

            ## Speedup
            if not self.project.BuildOption("save-disk"):
                if objectVersion == 38:
                    settings["PRECOMPILE_PREFIX_HEADER"]="YES"
                else:
                    settings["GCC_PRECOMPILE_PREFIX_HEADER"]="YES"

            vars = mf.get_variables()
            tmp_vars = copy.deepcopy(vars)

            tmp_vars["INCLUDES"] = "" ## INCLUDES are handled elsewhere
            flags=makefile.expand_variables("$(CCFLAGS)",  tmp_vars)
            c_flags=[]
            opt_flags=[]
            warn_flags=[]

            state = ""
            debug="NO"

            for flag in string.split(flags):
                if state:
                    if state == "prefix_header":
                        settings["PREFIX_HEADER"]=flag
                    state=""
                else:
                    ft=flag[:2]
                    if ft == "-W":
                        warn_flags.append(flag)
                    elif ft == "-O":
                        opt_flags.append(flag)
                    elif ft == "-g":
                        debug="YES"
                        if objectVersion == 38:
                            if settings.has_key("DEBUG_SYMBOLS"):
                                del settings["DEBUG_SYMBOLS"]
                        else:
                            settings["GCC_GENERATE_DEBUGGING_SYMBOLS"]="YES"
                    elif flag in [ "-p", "-pg" ]:
                        settings["PROFILING_CODE"]="YES"
                    elif flag == "-include":
                        state="prefix_header"
                    elif flag == "-faltivec" and objectVersion > 38:
                        settings["GCC_ALTIVEC_EXTENSIONS"]="YES"
                    elif flag == "-fobjec-exceptions":
                        settings["GCC_ENABLE_OBJC_EXCEPTIONS"]="YES"
                    else:
                        c_flags.append(flag)

            settings["OTHER_CFLAGS"] = string.join(c_flags)
            settings["WARNING_CFLAGS"] = string.join(warn_flags);
            settings["OPTIMIZATION_CFLAGS"] = string.join(opt_flags);

            settings["HEADER_SEARCH_PATHS"] = string.join(project.includes," ")
            settings["FRAMEWORK_SEARCH_PATHS"] = ""

            #settings["DSTROOT"]=self.project.target_dir
            settings["DEPLOYMENT_LOCATION"]=""
            settings["RIBOSOME_OUTPUT_DIR"]=project.output_dir

            if objectVersion > 38:
                settings["COPY_PHASE_STRIP"]="NO"
                settings["GCC_ENABLE_FIX_AND_CONTINUE"]=debug
                settings["ZERO_LINK"]="no"
            else:
                if not project.BuildOption("debug"):
                    settings["DEPLOYMENT_POSTPROCESSING"]="YES"

            target.buildSettings = settings

            ## Sources
            for file in project.sources:
                ext = os.path.splitext(file)[1]
                if ext in [ ".r" ]:
                    self.rez_phase.files.append(PBXBuildFile(
                        self.pb.add_source_file(file)))
                else:
                    self.source_phase.files.append(PBXBuildFile(
                        self.pb.add_source_file(file)))

            ## Resources, add res/mac-projectbuilder/*

            for p in project.resource_directories:
                variants={}
                if os.path.isdir(p):
                    for f in os.listdir(p):
                        if f in [ "CVS", ".DS_Store" ]:
                            continue

                        full_name=os.path.join(p,f)
                        if os.path.isdir(full_name):
                            if full_name[-6:] == ".lproj":
                                for res in os.listdir(full_name):
                                    if res in [ "CVS", ".DS_Store" ]:
                                        continue

                                    full_res=os.path.join(full_name, res)
                                    if variants.has_key(res):
                                        variants[res].append(full_res)
                                    else:
                                        variants[res]=[full_res]
                                continue
                            else:
                                tmp=self.pb.add_resource_folder(full_name, "Resources/"+os.path.basename(p))
                        else:
                            tmp=self.pb.add_resource_file(full_name, "Resources/"+os.path.basename(p))

                        self.resource_phase.files.append(PBXBuildFile(tmp))

                ## Create Variants
                res_group=self.pb.create_group(os.path.join(pb.basename,
                                                            "Resources/"+os.path.basename(p)))

                for var in variants.keys():
                    g=PBXVariantGroup(var)

                    for res in variants[var]:
                        f=PBXFileReference(res)
                        f.name=os.path.basename(string.split(res,".lproj")[0])
                        g.children.append(f)

                    res_group.children.append(g)
                    self.resource_phase.files.append(PBXBuildFile(g))


            ## Integrate copy phases
            for (f, t) in project.copy_phases:
                cp_phase = PBXCopyFilesBuildPhase()
                cp_phase.dstPath=t
                cp_phase.dstSubfolderSpec=1
                cp_phase.buildActionMask=12
                cp_phase.files=[]
                for file in f:
                    if os.path.isdir(file):
                        tmp=self.pb.add_resource_folder(file, "Other files")
                    else:
                        tmp=self.pb.add_resource_file(file, "Other files")
                    cp_phase.files.append(PBXBuildFile(tmp))


                target.buildPhases = [ cp_phase ] + target.buildPhases

            ## UGLY, we add *ALL* header files here
    ##         potential_headers = ["."]
    ##         for h in potential_headers:
    ##             if os.path.isdir(h):