# This script generates the PyKDE configuration and generates the Makefiles. # # Copyright (c) 2004 # Riverbank Computing Limited # Jim Bublitz # # This file is part of PyKDE. # # This copy of PyKDE is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by the Free # Software Foundation; either version 2, or (at your option) any later # version. # # PyKDE is supplied in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more # details. # # You should have received a copy of the GNU General Public License along with # PyKDE; see the file LICENSE. If not, write to the Free Software Foundation, # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. import sys import os import string import glob import getopt import shutil import py_compile try: import sip_tqt_config except: print ("Can't find sip_tqt_config.py (expected in sys.path)") print ("Have you built the correct version of sip-tqt?") sys.exit (-1) try: from PyTQt import pytqtconfig except: sip_tqt_config.error ("Can't find pytqtconfig.py in sys.path - exiting") topsrcdir = os.path.dirname(os.path.abspath(__file__)) has_objdir = topsrcdir != os.path.abspath(os.path.curdir) if not has_objdir: topsrcdir = None def srcPath(filename): if topsrcdir is not None: return os.path.join(topsrcdir, filename) return filename topsrcdir = os.path.dirname(os.path.abspath(__file__)) has_objdir = topsrcdir != os.path.abspath(os.path.curdir) if not has_objdir: topsrcdir = None def srcPath(filename): if topsrcdir is not None: return os.path.join(topsrcdir, filename) return filename # Get the SIP-TQt configuration. sipcfg = sip_tqt_config.Configuration() pytqtcfg = pytqtconfig.Configuration () # Initialise the globals. pytde_version = 0x031006 pytde_version_str = "3.16.6" kde_version = None kde_version_str = None kde_version_sfx = None kde_version_extra = None kde_max_version = 0x030503 sip_min_v4_version = 0x040900 tqt_min_version = 0x030200 pytqt_min_version = 0x031000 kde_sip_flags = [] # Command line options. opt_pytdemoddir = sipcfg.default_mod_dir opt_pytdesipdir = sipcfg.default_sip_dir opt_debug = 0 opt_concat = None opt_split = 1 opt_releasegil = 0 opt_tracing = 0 opt_static = 0 opt_tdebasedir = None opt_kdelibdir = None opt_kdeincdir = None opt_dep_warnings = 0 opt_libdir = "lib" opt_dist_name = "" pytde_modules = ["dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tderesources", "tdeabc", "tdeutils", "tdefile", "tdeparts",\ "tdehtml", "tdespell", "tdeprint", "tdemdi"] #, "tdespell2"] pytde_imports = { "dcop": ["PyTQt.tqt"], "tdecore": ["PyTQt.tqt", "dcop"], # "tdesu": ["PyTQt.tqt", "dcop", "tdecore"], "tdefx": ["PyTQt.tqt", "dcop", "tdecore"], "tdeui": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx"], "tdeio": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui"], "tderesources": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"], "tdeabc": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tderesources"], "tdeutils": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"], "tdefile": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"], "tdeparts": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio"], "tdehtml": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeutils", "tdeio", "tdeparts"], "tdespell": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tdefile"], "tdeprint": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui"], "tdemdi": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui", "tdeio", "tdeparts"], "tdespell2": ["PyTQt.tqt", "PyTQt.tqtxml", "dcop", "tdecore", "tdefx", "tdeui"] } kde_includes = { "dcop": None, "tdecore": None, # "tdesu": ["tdesu"], "tdefx": None, "tdeui": None, "tdeio": ["tdeio"], "tderesources": ["tdeio", "../tdeio", "tderesources"], "tdeabc": ["tdeio", "../tdeio", "tderesources", "tdeabc"], "tdefile": ["tdeio", "../tdeio"], "tdeparts": ["tdeio", "../tdeio", "tdeparts"], "tdehtml": ["tdeio", "../tdeio", "tdeparts", "dom"], "tdespell": ["tdeio"], "tdeprint": ["tdeprint"], "tdemdi": ["tdemdi", "tdeio", "../tdeio", "tdeparts"], "tdeutils": ["tdeio", "../tdeio"] #, # "tdespell2": None } postProcess = { "dcop": None, "tdecore": [["-p ", "tdecore", "-o", "appQuit", "tdecore.py"], #["-p ", "tdecore", "-o", "fixTQVariant", "tdecore.sbf"], ["-p ", "tdecore", "-o", "fixSignal", "tdecorepart0.*"]], # "tdesu": None, "tdefx": None, "tdeui": None, #[["-p ", "tdeui", "-o", "shpix", "siptdeuiTDESharedPixmap.cpp"]], "tderesources": None, "tdeabc": None, "tdeio": None, "tdefile": None, "tdeparts": None, "tdehtml": None, "tdespell": None, "tdeprint": None, "tdemdi": None, "tdeutils": None #, # "tdespell2": None } opt_startModName = "" opt_startmod = 0 opt_endmod = len (pytde_modules) def check_gcc (): global opt_concat os.system ("gcc -dumpversion > gccvers.txt") m = open ('gccvers.txt', 'r') vers = m.read().strip() m.close () os.unlink ('gccvers.txt') print("gcc version %s" % vers) if opt_concat == None: if vers < "4.0.0" or vers >= "4.0.3": opt_concat = 1 else: opt_concat = 0 if opt_concat == 1: print("concatenating files") else: print("no concatenation") print() def init_and_check_sanity (): """ Do some initialization and check various versions and attributes of sip-tqt and PyTQt installations """ check_gcc () # Check SIP-TQt is new enough. if sipcfg.sip_version_str[:8] != "snapshot": minv = None if sipcfg.sip_version < sip_min_v4_version: minv = sip_min_v4_version if minv: sipcfg.error("This version of PyKDE requires SIP-TQt v%s or later" % sipcfg.version_to_string(minv)) # Check SIP-TQt has TQt support enabled and check version if pytqtcfg.tqt_version == 0: sip_tqt_config.error("SIP-TQt has been built with TQt support disabled.") if pytqtcfg.tqt_version < tqt_min_version: sip_tqt_config.error("SIP-TQt has been built with an unsupported TQt version (%s)"\ % sipcfg.version_to_string (sipcfg.tqt_version)) # Check PyTQt built with libtqt-mt if pytqtcfg.tqt_threaded == 0: sip_tqt_config.error ("PyKDE requires a threaded TQt version (libtqt-mt)") # Check PyTQt version if pytqtcfg.pytqt_version < pytqt_min_version: sipcfg.error("This version of PyKDE requires PyTQt v%s or later"\ % pytqtcfg.version_to_string(pytqtcfg.pytqt_version)) # find the libs, includes, and version info check_kde_installation () def usage(rcode = 2): """Display a usage message and exit. rcode is the return code passed back to the calling process. """ print("Usage:") print(" python configure.py [-h] [-c] [-d dir] [-g] [-j #] [-k] [-n dir] [-o dir] [-r] [-u] [-v dir] [-z file]") print("where:") print(" -h displays this help message") print(" -c concatenates each module's C/C++ source files [default]") print(" -d dir where the PyKDE modules will be installed [default %s]" % opt_pytdemoddir) print(" -e lib explicitly specify the python library") print(" -g always release the GIL (SIP-TQt v3.x behaviour)") print(" -i no concatenation of each module's C/C++ source files") print(" -j # splits the concatenated C++ source files into # pieces [default 1]") print(" -k dir the KDE base directory") print(" -L dir the library directory name [default lib]") print(" -n dir the directory containing the KDE lib files") print(" -o dir the directory containing the KDE header files") print(" -r generates code with tracing enabled [default disabled]") print(" -u build with debugging symbols") print(" -v dir where the PyKDE .sip files will be installed [default %s]" % opt_pytdesipdir) print(" -w turn on KDE deprecated object warnings when compiling [default off]") print(" -z file the name of a file containing command line flags") sys.exit(rcode) def inform_user(stage): """Tell the user the option values that are going to be used. """ if stage == 0: print() print(" PyKDE version %s" % pytde_version_str) print(" -------") print() sip_tqt_config.inform ("Python include directory is %s" % sipcfg.py_inc_dir) sip_tqt_config.inform ("Python version is %s" % sip_tqt_config.version_to_string (sipcfg.py_version)) print() sip_tqt_config.inform ("sip-tqt version is %s (%s)" % (sipcfg.sip_version_str, sip_tqt_config.version_to_string (sipcfg.sip_version))) print() sip_tqt_config.inform ("TQt directory is %s" % pytqtcfg.tqt_dir) sip_tqt_config.inform ("TQt version is %s" % sip_tqt_config.version_to_string (pytqtcfg.tqt_version)) print() sip_tqt_config.inform ("PyTQt directory is %s" % pytqtcfg.pytqt_sip_dir) sip_tqt_config.inform ("PyTQt version is %s (%s)" % (pytqtcfg.pytqt_version_str, sip_tqt_config.version_to_string (pytqtcfg.pytqt_version))) print() elif stage == 1: sip_tqt_config.inform ("KDE base directory is %s" % opt_tdebasedir) sip_tqt_config.inform ("KDE include directory is %s" % opt_kdeincdir) sip_tqt_config.inform ("KDE lib directory is %s" % opt_kdelibdir) sip_tqt_config.inform ("lib directory is %s" % opt_libdir) elif stage == 2: sip_tqt_config.inform ("KDE version is %s (0x%x)" % (kde_version_str, kde_version)) print() sip_tqt_config.inform("PyKDE modules will be installed in %s" % opt_pytdemoddir) sip_tqt_config.inform("PyKDE .sip files will be installed in %s" % opt_pytdesipdir) print() def create_config(module, template): """Create the PyKDE configuration module so that it can be imported by build scripts. module is the module file name. template is the template file name. """ sip_tqt_config.inform("Creating %s..." % module) content = { "pytde_version": pytde_version, "pytde_version_str": pytde_version_str, "kde_version": kde_version, "kde_version_str": kde_version_str, "kde_version_sfx": kde_version_sfx, "kde_version_extra": kde_version_extra, # "pytde_bin_dir": opt_pytdebindir, "pytde_mod_dir": opt_pytdemoddir, "pytde_sip_dir": opt_pytdesipdir, "pytde_modules": pytde_modules, "pytde_kde_sip_flags": kde_sip_flags, "tdebasedir": opt_tdebasedir, "kdelibdir": opt_kdelibdir, "libdir": opt_libdir, "kdeincdir": opt_kdeincdir, "pytde_modules": pytde_modules, "dist_name": opt_dist_name } sip_tqt_config.create_config_module(module, template, content) def getKDEVersion (versFile): if not os.path.isfile (versFile): return major = None minor = None micro = None global kde_version, kde_version_str, kde_version_sfx, kde_version_extra f = open (versFile) l = f.readline () ok = 0 while not ok and l: wl = l.split() if len(wl) == 3 and wl[0] == "#define": if wl[1] == "TDE_VERSION_MAJOR": major = wl[2].strip() if wl[1] == "TDE_VERSION_MINOR": minor = wl[2].strip() if wl[1] == "TDE_VERSION_RELEASE": micro = wl[2].strip() if major and minor and micro: ok = 1 l = f.readline() f.close() if micro >= "90" and minor == "2": micro = "0" minor = "3" kde_version = (int (major) << 16) + (int (minor) << 8) + int (micro) if kde_version > kde_max_version: print() sip_tqt_config.inform ("*** True KDE version is %s -- building for KDE %s ***" % (hex (kde_version), hex (kde_max_version))) print() kde_version = kde_max_version major = hex ((kde_version & 0xff0000) >> 16) [ 2:] minor = hex ((kde_version & 0x00ff00) >> 8) [ 2:] micro = hex (kde_version & 0x0000ff) [ 2:] if ok: kde_version_str = ".".join([major, minor, micro]) kde_version_sfx = "".join(["-kde", major, minor, micro, ".diff"]) kde_version_extra = "".join(["kde", major, minor, micro]) else: sip_tqt_config.error ("KDE version not found in %s" % versFile) global postProcess def search (target, searchPath): if not searchPath: return path = None for searchEntry in searchPath: if os.path.isdir (searchEntry)\ and (not target or os.path.isfile (os.path.join (searchEntry, target))): path = searchEntry break return path def discoverKDE3 (): global opt_kdeincdir, opt_tdebasedir, opt_kdelibdir, opt_libdir if not opt_tdebasedir: kdeSearchPaths = [] libSearchPaths = [] incSearchPaths = [] try: kdeSearchPaths.append (os.environ ["TDEDIR"]) except: pass kdeSearchPaths.append (os.path.join ("/opt", "trinity")) kdeSearchPaths.append ("/usr") opt_tdebasedir = search (None, kdeSearchPaths) if not opt_kdelibdir: libSearchPaths = [os.path.join (opt_tdebasedir, "lib"), os.path.join (opt_tdebasedir, "lib64"), os.path.join (opt_tdebasedir, opt_libdir)] # print opt_libdir opt_kdelibdir = search ("libtdecore.so", libSearchPaths) if not opt_kdeincdir: incSearchPaths = [os.path.join (opt_tdebasedir, "include")] incSearchPaths.append (os.path.join (opt_tdebasedir, "include", "tde")) # Red Hat opt_kdeincdir = search ("tdeapplication.h", incSearchPaths) def check_kde_installation(): """Check the KDE installation and get the version number """ # Check the KDE header files have been installed. discoverKDE3 () if not opt_tdebasedir: sip_tqt_config.error ("Couldn't locate KDE3 base directory") if not opt_kdeincdir: sip_tqt_config.error ("Couldn't locate KDE3 include directory (%s is KDE base)" % opt_tdebasedir) if not opt_kdelibdir: sip_tqt_config.error ("Couldn't locate KDE3 lib directory (%s is KDE base)" % opt_tdebasedir) tdeversion_h = os.path.join(opt_kdeincdir, "tdeversion.h") inform_user (1) if not os.access(tdeversion_h, os.F_OK): sip_tqt_config.error("tdeversion.h could not be found in %s." % opt_kdeincdir) # Get the KDE version number. getKDEVersion(tdeversion_h) inform_user (2) def create_top_level (mname): """ Create the top level sip-tqt file mod.sip from mod.sip-in and add/delete any %Included sip-tqt files per the current KDE version """ diff = srcPath(os.path.join ("sip", mname, mname + kde_version_sfx)) plus = [] minus = [] if os.path.exists (diff): d = open (diff) line = d.readline() while line: if line.find ("+") == 0: plus.append (line [2:]) elif line.find ("-") == 0: minus.append (line [2:]) line = d.readline() sipin = open (srcPath(os.path.join ("sip", mname, mname + "mod.sip.in"))) sipout = open (srcPath(os.path.join ("sip", mname, mname + "mod.sip")), "w") line = sipin.readline() while line: if line.find("%Include") == 0: inclFound = 1 if minus and line in minus: line = sipin.readline() continue sipout.write (line) elif line.find ("@mark@") == 0: for p in plus: sipout.write (p) elif mname == "tdeabc" and kde_version < 0x030200 and line.find("tderesourcesmod.sip") >= 0: pass else: sipout.write (line) line = sipin.readline() sipin.close () sipout.close () if mname == "tdehtml": # PyKDE < 3.3.0 doesn't provide tdeutils (and tdehtml doesn't need it) sippath = srcPath(os.path.join ("sip", mname)) if kde_version < 0x030300: sipin = open (os.path.join (sippath, mname + "mod.sip")) sipout = open (os.path.join (sippath, mname + "mod.sip.new"), "w") for line in sipin: if line.find ("tdeutilsmod.sip") > 0: continue sipout.write (line) sipin.close () sipout.close () os.unlink (os.path.join (sippath, mname + "mod.sip")) os.rename (os.path.join (sippath, mname + "mod.sip.new"), os.path.join (sippath, mname + "mod.sip")) os.system ("cp %s %s" % (os.path.join (sippath, "tdehtml_part.sip.323"), os.path.join (sippath, "tdehtml_part.sip"))) else: os.system ("cp %s %s" % (os.path.join (sippath, "tdehtml_part.sip.330"), os.path.join (sippath, "tdehtml_part.sip"))) def check_distribution (): dist = glob.glob ("/etc/*-release") kde_sip_flags.append ("-t") kde_sip_flags.append ("ALL") for file in dist: if file.find ("andrake") > 0: kde_sip_flags.pop() kde_sip_flags.append ("D_MANDRAKE") def set_sip_flags(): """Set the SIP-TQt platform, version and feature flags. """ global kde_sip_flags check_distribution () kde_sip_flags.append (pytqtcfg.pytqt_tqt_sip_flags) kdetags = { 0x030001: "KDE_3_0_0", 0x030003: "KDE_3_0_1", 0x030100: "KDE_3_0_3", 0x030101: "KDE_3_1_0", 0x030102: "KDE_3_1_1", 0x030103: "KDE_3_1_2", 0x030104: "KDE_3_1_3", 0x030105: "KDE_3_1_4", 0x030200: "KDE_3_1_5", 0x030201: "KDE_3_2_0", 0x030202: "KDE_3_2_1", 0x030203: "KDE_3_2_2", 0x030300: "KDE_3_2_3", 0x030301: "KDE_3_3_0", 0x030302: "KDE_3_3_1", 0x030400: "KDE_3_3_2", 0x030401: "KDE_3_4_0", 0x030402: "KDE_3_4_1", 0x030403: "KDE_3_4_2", 0x030500: "KDE_3_4_3", 0x030501: "KDE_3_5_0", 0x030502: "KDE_3_5_1", 0x030503: "KDE_3_5_2", 0x040000: "KDE_3_5_3" } kde_sip_flags.append("-t") kde_sip_flags.append(sip_tqt_config.version_to_sip_tag(kde_version, kdetags, "KDE")) def generate_code(mname, imports=None, extra_cflags=None, extra_cxxflags=None, extra_define=None, extra_include_dir=None, extra_lflags=None, extra_lib_dir=None, extra_lib=None, extra_libs=None, opengl=0, sip_flags=None): """Generate the code for a module. mname is the name of the module. imports is the list of PyTQt/PyKDE modules that this one %Imports. extra_cflags is a string containing additional C compiler flags. extra_cxxflags is a string containing additional C++ compiler flags. extra_define is a name to add to the list of preprocessor defines. extra_include_dir is the name of a directory to add to the list of include directories. extra_lflags is a string containing additional linker flags. extra_lib_dir is the name of a directory to add to the list of library directories. extra_lib is the name of an extra library to add to the list of libraries. opengl is set if the module needs OpenGL support. sip_flags is the list of sip-tqt flags to use instead of the defaults. """ sip_tqt_config.inform("Generating the C++ source for the %s module..." % mname) create_top_level (mname) try: #create_top_level (mname) pass except: sip_tqt_config.error ("Couldn't create top level sip-tqt file for %s" % mname) try: shutil.rmtree(mname) except: pass try: os.mkdir(mname) except: sip_tqt_config.error("Unable to create the %s directory." % mname) # Build the SIP-TQt command line. argv = [sipcfg.sip_bin] argv.extend(kde_sip_flags) if opt_concat: argv.append("-j") if mname == "tdeui" and opt_split == 1: splits = 2 else: splits = opt_split argv.append(str(splits)) if opt_tracing: argv.append("-r") if opt_releasegil: argv.append("-g") argv.append("-c") argv.append(mname) buildfile = os.path.join(mname, mname + ".sbf") argv.append("-b") argv.append(buildfile) argv.append("-I") argv.append(srcPath("sip")) pytqtInclPathSeen = 0 for mod in pytde_imports [mname]: if mod.find("PyTQt.tq") == 0 and not pytqtInclPathSeen: argv.append ("-I") argv.append (pytqtcfg.pytqt_sip_dir) pytqtInclPathSeen = 1 elif mod == "dcop" or mod.find("k") == 0 or mod.find("tde") == 0: subdir = os.path.join(srcPath("sip"), mod) argv.append("-I") argv.append(subdir) # SIP-TQt assumes POSIX style path separators. argv.append(srcPath("/".join(["sip", mname, mname + "mod.sip"]))) # finally, run SIP-TQt and generate the C++ code os.system (" ".join(argv)) # post process the C++ code for TQT_NO_TRANSLATION if os.system (" ".join ([sys.executable, srcPath("postproc")] + ['-p', mname, "-o", "tr", "*.cpp"])) != 0: sip_tqt_config.error ("Post processing of C++ code failed %s (tr)" % mname) # Check the result. if not os.access(buildfile, os.F_OK): sip_tqt_config.error("Unable to create the C++ code.") if mname == "tdecore" and not opt_concat: postProcess ["tdecore"][-1][-1] = "tdecorecmodule.*" # Compile the Python stub. if sipcfg.sip_version < 0x040000: sip_tqt_config.inform("Compiling %s.py..." % mname) py_compile.compile(os.path.join(mname, mname + ".py"), os.path.join(mname, mname + ".pyc")) elif mname == "tdecore": postProcess ["tdecore"][-1][-1] = "sip" + postProcess ["tdecore"][-1][-1] # needs to be here (not earlier) to catch .py files if any if postProcess [mname]: for s in postProcess [mname]: if os.system (" ".join ([sys.executable, srcPath("postproc")] + s)) != 0: sip_tqt_config.error ("Post processing of C++ code failed %s (%s)" % (mname, s [3])) # Generate the Makefile. sip_tqt_config.inform("Creating the Makefile for the %s module..." % mname) installs = [] if mname == "dcop": if has_objdir: installs.append ([[srcPath("extensions/dcopext.py"), srcPath("extensions/dcopexport.py")], opt_pytdemoddir]) else: installs.append ([["../extensions/dcopext.py", "../extensions/dcopexport.py"], opt_pytdemoddir]) if sipcfg.sip_version >= 0x040000: warnings = 1 else: warnings = 0 installs.append([[mname + ".py", mname + ".pyc"], opt_pytdemoddir]) sipfiles = [] # for s in glob.glob("sip/*.sip"): # sipfiles.append(os.path.join("..", "sip", os.path.basename(s))) for s in os.listdir (srcPath(os.path.join ("sip", mname))): if s.endswith (".sip"): if has_objdir: sipfiles.append(srcPath(os.path.join("sip", mname, os.path.basename(s)))) else: sipfiles.append(os.path.join("..", "sip", mname, os.path.basename(s))) installs.append([sipfiles, os.path.join(opt_pytdesipdir, mname)]) makefile = sip_tqt_config.SIPModuleMakefile( configuration = pytqtcfg, build_file = mname + ".sbf", dir = mname, install_dir = opt_pytdemoddir, installs = installs, tqt = 1, opengl = opengl, warnings = warnings, static = opt_static, debug = opt_debug, ) if extra_cflags: makefile.extra_cflags.append(extra_cflags) if extra_cxxflags: makefile.extra_cxxflags.append(extra_cxxflags) if opt_dep_warnings == 0: makefile.extra_cflags.append ("-Wno-deprecated-declarations") makefile.extra_cxxflags.append ("-Wno-deprecated-declarations") if extra_define: makefile.extra_defines.append(extra_define) if has_objdir: makefile.extra_include_dirs.append (srcPath(os.path.join("extra", kde_version_extra))) else: makefile.extra_include_dirs.append (os.path.join ("..", "extra", kde_version_extra)) makefile.extra_include_dirs.append (opt_kdeincdir) if kde_includes [mname]: for incdir in kde_includes [mname]: if "/" not in incdir: makefile.extra_include_dirs.append (os.path.join (opt_kdeincdir, incdir)) else: makefile.extra_include_dirs.append (incdir) if extra_include_dir: makefile.extra_include_dirs.append(extra_include_dir) makefile.extra_include_dirs.append ("/usr/include/tqt") if extra_lflags: makefile.extra_lflags.append(extra_lflags) makefile.extra_lib_dirs.append (opt_kdelibdir) if extra_lib_dir: makefile.extra_lib_dirs.append(extra_lib_dir) if extra_lib == "dcop": extra_lib = "DCOP" elif extra_lib == "tdefile": extra_lib = "tdeio" makefile.extra_libs.append(extra_lib) if extra_lib == "tdefx": makefile.extra_libs.append ("tdecore") if extra_lib == "tdespell": makefile.extra_libs.append ("tdeui") if extra_lib == "tdeabc" and kde_version >= 0x030200: makefile.extra_libs.append ("tdeabc_file") if extra_lib == "tdeparts" and kde_version >= 0x030500: makefile.extra_lib_dirs.append (os.path.join (opt_kdelibdir, "trinity")) if extra_lib == "tdeprint": makefile.extra_cflags.append ("-fno-rtti") makefile.extra_cxxflags.append ("-fno-rtti") if extra_libs: makefile.extra_libs.extend(extra_libs) if sipcfg.sip_version < 0x040000 and imports: # Inter-module links. for im in imports: makefile.extra_lib_dirs.insert(0, os.path.join("..", im)) makefile.extra_libs.insert(0, makefile.module_as_lib(im)) makefile.generate() print() def create_makefiles(): """Create the additional Makefiles. """ subdirs = pytde_modules[:] sip_tqt_config.inform("Creating top level Makefile...") sip_tqt_config.ParentMakefile( configuration = pytqtcfg, subdirs = subdirs, installs= [("pytdeconfig.py", opt_pytdemoddir), (srcPath("contrib/tdepyuic"), opt_tdebasedir + "/bin")] ).generate() def fileOpts (fn): try: optfile = open (fn, 'r') except: error ("Could not open option file %s" % (fn)) opts = [] for line in optfile.readlines (): if (line [0] == '#') or (line == '\n'): continue elif line [0] == '-': opts.append ((line [0:2], line[2:].strip())) else: opts.append (("-" + line [0:1], line[1:].strip())) print('Additional options: ', end=' ') for opt, arg in opts: print("%s %s " %(opt, arg)) print() return opts def main(argv): """Create the configuration module module. argv is the list of command line arguments. """ try: optlist, args = getopt.getopt(argv[1:], "hcd:e:gij:k:L:l:n:o:ruv:wz:") except getopt.GetoptError: usage() global opt_pytdemoddir, opt_pytdesipdir global opt_debug, opt_concat, opt_releasegil global opt_split, opt_tracing, opt_startModName global opt_startmod, opt_endmod global opt_tdebasedir, opt_kdelibdir, opt_kdeincdir, opt_libdir global pytde_modules, opt_dep_warnings, opt_dist_name global pytde_imports, kde_includes global opt_libpython opt_libpython = None # Look for '-z' first and process that switch # (command line switches override file switches) for opt, arg in optlist: if opt == "-z": optlist = fileOpts (arg) + optlist break elif opt == "-h": usage (0) else: if args: usage() for opt, arg in optlist: if opt == "-h": usage(0) elif opt == "-e": opt_libpython = arg # turns on concatentation (on by default, here for consistency) elif opt == "-c": opt_concat = 1 elif opt == "-d": opt_pytdemoddir = arg elif opt == "-g": opt_releasegil = 1 # turns off concatenation (on by default) elif opt == "-i": opt_concat = 0 elif opt == "-j": try: opt_split = int(arg) except: usage() elif opt == "-k": opt_tdebasedir = arg elif opt == "-L": opt_libdir = arg # allows build of single module (-lmodule) or all modules # beginning at specified module (-lmodule:) elif opt == "-l": opt_startModName = arg elif opt == "-n": opt_kdelibdir = arg elif opt == "-o": opt_kdeincdir = arg elif opt == "-r": opt_tracing = 1 elif opt == "-u": opt_debug = 1 elif opt == "-v": opt_pytdesipdir = arg elif opt == "-w": opt_dep_warnings = 1 inform_user (0) init_and_check_sanity () # Set the SIP-TQt platform, version and feature flags. if kde_version < 0x030200: pytde_modules.remove ("tdemdi") pytde_modules.remove ("tderesources") pytde_imports ["tdeabc"].remove ("tderesources") kde_includes ["tdeabc"].remove ("tderesources") if kde_version < 0x030300: pytde_modules.remove ("tdeutils") # pytde_modules.remove ("tdespell2") pytde_imports ["tdehtml"].remove ("tdeutils") opt_endmod = len (pytde_modules) if opt_startModName != "": if opt_startModName in pytde_modules: single = opt_startModName [-1] != ":" if not single: opt_startModName = opt_startModName [:-1] try: opt_startmod = pytde_modules.index (opt_startModName) if single: opt_endmod = opt_startmod + 1 except: sip_tqt_config.error ("%s is not a PyKDE module" % opt_startModName) print("PyKDE modules to be built:\n %s\n" % " ".join(pytde_modules[opt_startmod:opt_endmod])) set_sip_flags() for module in pytde_modules [opt_startmod:opt_endmod]: extra_libs = [] if opt_libpython: extra_libs.append(opt_libpython) generate_code (module, pytde_imports [module], extra_lib = module, extra_libs = extra_libs) # Create the additional Makefiles. create_makefiles() # Install the configuration module. create_config("pytdeconfig.py", srcPath("pytdeconfig.py.in")) def reporting_msg (): print(""" If reporting errors, paste all of the output above into your message and post to the PyKDE mailing list at: mailto: PyKDE@mats.imk.fraunhofer.de subscribe: http://mats.imk.fraunhofer.de/mailman/listinfo/pytde You can redirect the output into a file (> output.txt) if needed """) ############################################################################### # The script starts here. ############################################################################### if __name__ == "__main__": try: main(sys.argv) except SystemExit: reporting_msg () raise except: reporting_msg () print(""" An internal error occured. Please report all output from the program, including the following traceback, to the PyKDE mailing list """) raise