source: packages/lang/pyqt4/patches/100-cross-compile.patch @ 22743

Last change on this file since 22743 was 22743, checked in by mb, 6 years ago

Add PyQt4

File size: 14.0 KB
  • PyQt-x11-gpl-4.7.4

    ---
     configure.py |  218 ++++++++++++++++++++++++++++++++++++++++-------------------
     1 file changed, 149 insertions(+), 69 deletions(-)
    
    old new import os 
    3333import glob 
    3434import optparse 
    3535import shutil 
     36import re 
    3637 
    3738import sipconfig 
    3839 
    def create_optparser(): 
    173174            metavar="PLUGIN", dest="staticplugins", help="add PLUGIN to the " 
    174175            "list be linked (if Qt is built as static libraries)") 
    175176 
    176     if sys.platform != 'win32': 
    177         if sys.platform in ('linux2', 'darwin'): 
    178             pip_default = True 
    179             pip_default_str = "enabled" 
    180         else: 
    181             pip_default = False 
    182             pip_default_str = "disabled" 
    183  
    184         g.add_option("--protected-is-public", action="store_true", 
    185                 default=pip_default, dest="prot_is_public", 
    186                 help="enable building with 'protected' redefined as 'public' " 
    187                         "[default: %s]" % pip_default_str) 
    188         g.add_option("--protected-not-public", action="store_false", 
    189                 dest="prot_is_public", 
    190                 help="disable building with 'protected' redefined as 'public'") 
    191         g.add_option("-q", "--qmake", action="callback", metavar="FILE", 
    192                 default=qmake, dest="qmake", callback=store_abspath_file, 
    193                 type="string", 
    194                 help="the pathname of qmake [default: %s]" % (qmake or "none")) 
     177    g.add_option("--protected-is-public", action="store_true", 
     178            default=True, dest="prot_is_public", 
     179            help="enable building with 'protected' redefined as 'public' " 
     180                    "[default: True]") 
     181    g.add_option("--protected-not-public", action="store_false", 
     182            dest="prot_is_public", 
     183            help="disable building with 'protected' redefined as 'public'") 
     184    g.add_option("-q", "--qmake", action="callback", metavar="FILE", 
     185            default=qmake, dest="qmake", callback=store_abspath_file, 
     186            type="string", 
     187            help="the pathname of qmake [default: %s]" % (qmake or "none")) 
    195188 
    196189    g.add_option("-s", "--dbus", action="callback", metavar="DIR", 
    197190            dest="pydbusincdir", callback=store_abspath_dir, type="string", 
    def create_optparser(): 
    199192            "[default: supplied by pkg-config]") 
    200193    p.add_option_group(g) 
    201194 
    202     if sys.platform == 'darwin': 
    203         g = optparse.OptionGroup(p, title="MacOS X Configuration") 
    204         g.add_option("--use-arch", action="store", metavar="ARCH", 
    205                 dest="use_arch", choices=["i386", "x86_64", "ppc"], 
    206                 help="the architecture to use when running pyuic4 " 
    207                         "[default: system default]") 
    208         p.add_option_group(g) 
     195    g = optparse.OptionGroup(p, title="Arch Configuration") 
     196    g.add_option("--use-arch", action="store", metavar="ARCH", 
     197            dest="use_arch", choices=["", "i386", "x86_64", "ppc", "arm"], 
     198            default="", 
     199            help="the architecture to use when running pyuic4 " 
     200                    "[default: system default]") 
     201    p.add_option_group(g) 
    209202 
    210203    # Installation. 
    211204    g = optparse.OptionGroup(p, title="Installation") 
    def create_optparser(): 
    264257            "QTDIR/qsci]") 
    265258    p.add_option_group(g) 
    266259 
     260    # Crosscompilation 
     261    g = optparse.OptionGroup(p, title="Crosscompilation") 
     262    g.add_option("--crosscompile", action="store_true", 
     263                 default=False, dest="crosscompile", 
     264                 help="Set, if cross-compiling") 
     265    g.add_option("--sipconfig-macros", action="callback", metavar="FILE", 
     266                 default=None, dest="sipconfig_macros", type="string", 
     267                 callback=store_abspath_file, 
     268                 help="Path to a file containing sipconfig macros") 
     269    g.add_option("--qmake-prefix", action="append", 
     270                 default=[], dest="qmake_prefixes", type="string", 
     271                 help="Commandline prefix to qmake") 
     272    g.add_option("--qmake-spec", action="callback", metavar="FILE", 
     273                default=None, dest="qmake_spec", callback=store_abspath, 
     274                type="string", 
     275                help="the pathname to qmake spec file") 
     276    g.add_option("--qtdirs-file", action="callback", metavar="FILE", 
     277                 default=None, dest="qtdirs_file", callback=store_abspath_file, 
     278                 type="string", 
     279                 help="Path to a predefined qtdirs file") 
     280    g.add_option("--pydbus-installdir", action="callback", metavar="DIR", 
     281                 default=None, dest="pydbus_installdir", callback=store_abspath, 
     282                 type="string", 
     283                 help="Install dir for pydbus module") 
     284    p.add_option_group(g) 
     285 
    267286    return p 
    268287 
    269288 
    270289class pyrccMakefile(sipconfig.ProgramMakefile): 
    271290    """This class implements the Makefile for pyrcc.  This is specialised so 
    272     that pyrcc is automatically run against the examples. 
     291    that pyrcc is automatically run against the examples, if not crosscompiling. 
    273292    """ 
    274293 
    275294    def __init__(self): 
    class pyrccMakefile(sipconfig.ProgramMak 
    282301    def generate_target_default(self, mfile): 
    283302        """Generate the default target.""" 
    284303        sipconfig.ProgramMakefile.generate_target_default(self, mfile) 
     304        if opts.crosscompile: 
     305            return 
    285306 
    286307        # The correct call to pyrcc depends on the Python version. 
    287308        if sys.hexversion >= 0x03000000: 
    include(%s) 
    772793 
    773794            f.close() 
    774795 
    775             run_command("%s %s %s" % (opts.qmake, qmake_args, wrapped_pro)) 
     796            run_qmake("%s %s" % (qmake_args, wrapped_pro)) 
    776797            os.chdir(cwd) 
    777798 
    778799        sipconfig.inform("Creating QPy support libraries Makefile...") 
    include(%s) 
    825846        # not on Windows (so that normal console use will work). 
    826847        sipconfig.inform("Creating pyuic4 wrapper...") 
    827848 
    828         if sys.platform == 'darwin': 
    829             gui = True 
     849        if opts.use_arch: 
     850            gui = False#FIXME 
    830851            use_arch = opts.use_arch 
    831852        else: 
    832             gui = False 
    833             use_arch = '' 
     853            if sys.platform == 'darwin': 
     854                gui = True 
     855                use_arch = opts.use_arch 
     856            else: 
     857                gui = False 
     858                use_arch = '' 
    834859 
    835860        uicdir=os.path.join(pyqt_modroot, "uic") 
    836861        wrapper = sipconfig.create_wrapper(os.path.join(uicdir, "pyuic.py"), os.path.join("pyuic", "pyuic4"), gui, use_arch) 
    include(%s) 
    880905            py_major = sipcfg.py_version >> 16 
    881906            py_minor = (sipcfg.py_version >> 8) & 0x0ff 
    882907 
     908            print "FIXME CROSSCOMPILE" #FIXME: Crosscompile 
    883909            if sys.platform == 'win32': 
    884910                lib_dir_flag = quote("-L%s" % sipcfg.py_lib_dir) 
    885911                link = "%s -lpython%d%d" % (lib_dir_flag, py_major, py_minor) 
    include(%s) 
    938964                fout.write(prj) 
    939965                fout.close() 
    940966 
    941                 run_command("%s %s" % (opts.qmake, qmake_args)) 
     967                run_qmake(qmake_args) 
    942968                os.chdir(cwd) 
    943969 
    944970                tool.append("designer") 
    def create_config(module, template, macr 
    10561082    sipconfig.create_config_module(module, template, content, macros) 
    10571083 
    10581084 
     1085def run_qmake(args): 
     1086    pfx = " ".join(opts.qmake_prefixes) 
     1087    if opts.qmake_spec: 
     1088        spec = "-spec \"" + opts.qmake_spec + "\"" 
     1089    else: 
     1090        spec = "" 
     1091    run_command(pfx + " " + opts.qmake + " " + spec + " " + args) 
     1092 
    10591093def run_command(cmd): 
    10601094    """Run a command and display the output if verbose mode is enabled. 
    10611095 
    def check_dbus(): 
    12721306    """ 
    12731307    sipconfig.inform("Checking to see if the dbus support module should be built...") 
    12741308 
    1275     sout = get_command_stdout("pkg-config --cflags-only-I --libs dbus-1") 
    1276     iflags = sout.read().strip() 
     1309    if opts.crosscompile and not opts.pydbusincdir: 
     1310       sipconfig.inform("Crosscompiling but no dbus incdir specified. Disabling dbus.") 
     1311       return 
     1312 
     1313    if not opts.crosscompile: 
     1314        sout = get_command_stdout("pkg-config --cflags-only-I --libs dbus-1") 
     1315        iflags = sout.read().strip() 
     1316 
     1317        if not iflags: 
     1318            sipconfig.inform("DBus v1 does not seem to be installed.") 
     1319            return 
     1320 
     1321        # Using str() means it will work with both Python v2 and v3. 
     1322        for f in str(iflags).split(): 
     1323            if f.startswith("-I"): 
     1324                dbusincdirs.append(f[2:]) 
     1325            elif f.startswith("-L"): 
     1326                dbuslibdirs.append(f[2:]) 
     1327            elif f.startswith("-l"): 
     1328                dbuslibs.append(f[2:]) 
    12771329 
    1278     if not iflags: 
    1279         sipconfig.inform("DBus v1 does not seem to be installed.") 
    1280         return 
    1281  
    1282     # Using str() means it will work with both Python v2 and v3. 
    1283     for f in str(iflags).split(): 
    1284         if f.startswith("-I"): 
    1285             dbusincdirs.append(f[2:]) 
    1286         elif f.startswith("-L"): 
    1287             dbuslibdirs.append(f[2:]) 
    1288         elif f.startswith("-l"): 
    1289             dbuslibs.append(f[2:]) 
    1290  
    1291     try: 
    1292         import dbus.mainloop 
    1293     except: 
    1294         sipconfig.inform("The Python dbus module doesn't seem to be installed.") 
    1295         return 
     1330        try: 
     1331            import dbus.mainloop 
     1332        except: 
     1333            sipconfig.inform("The Python dbus module doesn't seem to be installed.") 
     1334            return 
    12961335 
    12971336    global pydbusmoddir 
    1298     pydbusmoddir = dbus.mainloop.__path__[0] 
     1337    if opts.pydbus_installdir: 
     1338        pydbusmoddir = opts.pydbus_installdir 
     1339    else: 
     1340        pydbusmoddir = dbus.mainloop.__path__[0] 
    12991341 
    13001342    # Try and find dbus-python.h.  We don't use pkg-config because it is broken 
    13011343    # for dbus-python (at least for versions up to and including v0.81.0). 
    def set_sip_flags(pyqt): 
    13811423 
    13821424    pyqt is the configuration instance. 
    13831425    """ 
     1426    #FIXME: Needs some crosscompile fixes. 
    13841427    # If we don't check for signed interpreters, we exclude the 'VendorID' 
    13851428    # feature 
    13861429    if not opts.vendorcheck: 
    def check_qt_installation(macros): 
    17791822def fix_qmake_args(args=""): 
    17801823    """Make any platform specific adjustments to the arguments passed to qmake. 
    17811824    """ 
     1825    if opts.crosscompile: 
     1826        return args 
    17821827    if sys.platform == "darwin": 
    17831828        # The Qt binary installer has macx-xcode as the default. 
    17841829        args = "-spec %s %s" % (sipcfg.platform, args) 
    int main(int, char **) 
    19301975 
    19311976    # Create the makefile, first making sure it doesn't already exist. 
    19321977    remove_file(make_file) 
    1933     run_command("%s %s %s" % (opts.qmake, qmake_args, pro_file)) 
     1978    run_qmake("%s %s" % (qmake_args, pro_file)) 
    19341979 
    19351980    if not os.access(make_file, os.F_OK): 
    19361981        sipconfig.error("%s failed to create a makefile. %s" % (opts.qmake, MSG_CHECK_QMAKE)) 
    int main(int, char **) 
    19521997    if not os.access(exe_file, os.X_OK): 
    19531998        sipconfig.error("Failed to determine the layout of your Qt installation. Try again using the --verbose flag to see more detail about the problem.") 
    19541999 
    1955     # Create the output file, first making sure it doesn't exist. 
    1956     remove_file(out_file) 
    1957     run_command(exe_file) 
     2000    if opts.qtdirs_file: 
     2001        # The user supplied a partial qtdirs.out file. We're probably crosscompiling. 
     2002        # Do _not_ try to execute our qtdirs exe. Take the supplied qtdirs.out files 
     2003        # instead and add the PyQt_... flags by grepping through the executable. 
     2004        # This assumes the executable is not compiled with -O0. 
     2005        read_qtdirs_file(opts.qtdirs_file) 
     2006        global qt_xfeatures 
     2007        print("Got %d features from qtdirs.out file: %s" % (len(qt_xfeatures), str(qt_xfeatures))) 
     2008        found = re.findall(r'PyQt_[\w]+', file(exe_file, "r").read()) 
     2009        print("Grepped %d features from qtdirs.exe file: %s" % (len(found), str(found))) 
     2010        qt_xfeatures.extend(found) 
     2011    else: 
     2012        # Create the output file, first making sure it doesn't exist. 
     2013        remove_file(out_file) 
     2014        run_command(exe_file) 
     2015 
     2016        if not os.access(out_file, os.F_OK): 
     2017            sipconfig.error("%s failed to create %s. Make sure your Qt v4 installation is correct." % (exe_file, out_file)) 
    19582018 
    1959     if not os.access(out_file, os.F_OK): 
    1960         sipconfig.error("%s failed to create %s. Make sure your Qt v4 installation is correct." % (exe_file, out_file)) 
     2019        # Read the directories. 
     2020        read_qtdirs_file(out_file) 
    19612021 
    1962     # Read the directories. 
    1963     f = open(out_file, "r") 
     2022def read_qtdirs_file(filename): 
     2023    f = open(filename, "r") 
    19642024    lines = f.read().strip().split("\n") 
    19652025    f.close() 
    19662026 
    int main(int, char **) 
    20222082            sipconfig.error("Qt has been built as static libraries so either the -g or -k argument should be used.") 
    20232083 
    20242084 
     2085def load_sipconfig_macros(filename): 
     2086    macros = {} 
     2087    fd = file(filename, "r") 
     2088    for line in fd.readlines(): 
     2089        line = line.split() 
     2090        try: 
     2091            key = line[0] 
     2092        except IndexError: 
     2093            sipconfig.error("Invalid sipconfig macros file format") 
     2094        value = "" 
     2095        try: 
     2096            value = " ".join(line[1:]) 
     2097        except IndexError: 
     2098            pass 
     2099        macros[key] = value 
     2100    return macros 
     2101 
     2102 
    20252103def main(): 
    20262104    """Create the configuration module module. 
    20272105    """ 
    def main(): 
    20362114    opts, args = p.parse_args() 
    20372115 
    20382116    # Provide defaults for platform-specific options. 
    2039     if sys.platform == 'win32': 
     2117    if sys.platform == 'win32' and not opts.crosscompile: 
    20402118        opts.qmake = find_default_qmake() 
    20412119        opts.prot_is_public = False 
    20422120 
    def main(): 
    20692147            # Install the API file if the default directory exists. 
    20702148            opts.api = os.path.isdir(opts.qscidir) 
    20712149 
    2072     # Replace the existing build macros with the ones from the Qt installation. 
    2073     macros = get_build_macros(args) 
    2074  
    2075     if macros is None: 
    2076         p.print_help() 
    2077         sys.exit(2) 
     2150    if opts.sipconfig_macros: 
     2151        macros = load_sipconfig_macros(opts.sipconfig_macros) 
     2152    else: 
     2153        # Replace the existing build macros with the ones from the Qt installation. 
     2154        macros = get_build_macros(args) 
     2155        if macros is None: 
     2156            p.print_help() 
     2157            sys.exit(2) 
    20782158 
    20792159    sipcfg.set_build_macros(macros) 
    20802160 
Note: See TracBrowser for help on using the repository browser.