From f8f69118cd78869bd7e2dd1f1d7d1b6e8baae6fa Mon Sep 17 00:00:00 2001 From: Vadim Zeitlin Date: Tue, 15 Dec 2015 14:53:12 +0100 Subject: [PATCH] Restore wxPython build scripts These scripts were removed in c9220befc7d151aea09e33963eb378d218a5cd46 but are still referenced in wxPython build instructions, so restore them. Closes #17289. --- build/tools/build-wxwidgets.py | 648 +++++++++++++++++++++++++++++++++ build/tools/builder.py | 255 +++++++++++++ 2 files changed, 903 insertions(+) create mode 100755 build/tools/build-wxwidgets.py create mode 100755 build/tools/builder.py diff --git a/build/tools/build-wxwidgets.py b/build/tools/build-wxwidgets.py new file mode 100755 index 0000000000..f625f8c198 --- /dev/null +++ b/build/tools/build-wxwidgets.py @@ -0,0 +1,648 @@ +#!/usr/bin/env python + +################################### +# Author: Kevin Ollivier +# Licence: wxWindows licence +################################### + +import os +import re +import sys +import builder +import glob +import optparse +import platform +import shutil +import types +import subprocess + +# builder object +wxBuilder = None + +# other globals +scriptDir = None +wxRootDir = None +contribDir = None +options = None +configure_opts = None +exitWithException = True +nmakeCommand = 'nmake.exe' + +verbose = False + + +def numCPUs(): + """ + Detects the number of CPUs on a system. + This approach is from detectCPUs here: http://www.artima.com/weblogs/viewpost.jsp?thread=230001 + """ + # Linux, Unix and MacOS: + if hasattr(os, "sysconf"): + if "SC_NPROCESSORS_ONLN" in os.sysconf_names: + # Linux & Unix: + ncpus = os.sysconf("SC_NPROCESSORS_ONLN") + if isinstance(ncpus, int) and ncpus > 0: + return ncpus + else: # OSX: + p = subprocess.Popen("sysctl -n hw.ncpu", shell=True, stdout=subprocess.PIPE) + return p.stdout.read() + + # Windows: + if "NUMBER_OF_PROCESSORS" in os.environ: + ncpus = int(os.environ["NUMBER_OF_PROCESSORS"]); + if ncpus > 0: + return ncpus + return 1 # Default + + +def getXcodePaths(): + base = getoutput("xcode-select -print-path") + return [base, base+"/Platforms/MacOSX.platform/Developer"] + + +def getVisCVersion(): + text = getoutput("cl.exe") + if 'Version 13' in text: + return '71' + if 'Version 15' in text: + return '90' + if 'Version 16' in text: + return '100' + # TODO: Add more tests to get the other versions... + else: + return 'FIXME' + + +def exitIfError(code, msg): + if code != 0: + print(msg) + if exitWithException: + raise builder.BuildError(msg) + else: + sys.exit(1) + + +def getWxRelease(wxRoot=None): + if not wxRoot: + global wxRootDir + wxRoot = wxRootDir + + configureText = open(os.path.join(wxRoot, "configure.in"), "r").read() + majorVersion = re.search("wx_major_version_number=(\d+)", configureText).group(1) + minorVersion = re.search("wx_minor_version_number=(\d+)", configureText).group(1) + + versionText = "%s.%s" % (majorVersion, minorVersion) + + if int(minorVersion) % 2: + releaseVersion = re.search("wx_release_number=(\d+)", configureText).group(1) + versionText += ".%s" % (releaseVersion) + + return versionText + + +def getFrameworkName(options): + # the name of the framework is based on the wx port being built + name = "wxOSX" + if options.osx_cocoa: + name += "Cocoa" + else: + name += "Carbon" + return name + + +def getPrefixInFramework(options, wxRoot=None): + # the path inside the framework that is the wx --prefix + fwPrefix = os.path.join( + os.path.abspath(options.mac_framework_prefix), + "%s.framework/Versions/%s" % (getFrameworkName(options), getWxRelease(wxRoot))) + return fwPrefix + + +def macFixupInstallNames(destdir, prefix, buildDir=None): + # When an installdir is used then the install_names embedded in + # the dylibs are not correct. Reset the IDs and the dependencies + # to use just the prefix. + print("**** macFixupInstallNames(%s, %s, %s)" % (destdir, prefix, buildDir)) + pwd = os.getcwd() + os.chdir(destdir+prefix+'/lib') + dylibs = glob.glob('*.dylib') # ('*[0-9].[0-9].[0-9].[0-9]*.dylib') + for lib in dylibs: + cmd = 'install_name_tool -id %s/lib/%s %s/lib/%s' % \ + (prefix,lib, destdir+prefix,lib) + print(cmd) + run(cmd) + for dep in dylibs: + if buildDir is not None: + cmd = 'install_name_tool -change %s/lib/%s %s/lib/%s %s/lib/%s' % \ + (buildDir,dep, prefix,dep, destdir+prefix,lib) + else: + cmd = 'install_name_tool -change %s/lib/%s %s/lib/%s %s/lib/%s' % \ + (destdir+prefix,dep, prefix,dep, destdir+prefix,lib) + print(cmd) + run(cmd) + os.chdir(pwd) + + +def run(cmd): + global verbose + if verbose: + print("Running %s" % cmd) + return exitIfError(os.system(cmd), "Error running %s" % cmd) + + +def getoutput(cmd): + sp = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + output = None + output = sp.stdout.read() + if sys.version_info > (3,): + output = output.decode('utf-8') # TODO: is utf-8 okay here? + output = output.rstrip() + rval = sp.wait() + if rval: + # Failed! + print("Command '%s' failed with exit code %d." % (cmd, rval)) + sys.exit(rval) + return output + + +def main(scriptName, args): + global scriptDir + global wxRootDir + global contribDir + global options + global configure_opts + global wxBuilder + global nmakeCommand + + scriptDir = os.path.dirname(os.path.abspath(scriptName)) + wxRootDir = os.path.abspath(os.path.join(scriptDir, "..", "..")) + + contribDir = os.path.join("contrib", "src") + installDir = None + + VERSION = tuple([int(i) for i in getWxRelease().split('.')[:2]]) + + if sys.platform.startswith("win"): + contribDir = os.path.join(wxRootDir, "contrib", "build") + + if sys.platform.startswith("win"): + toolkit = "msvc" + else: + toolkit = "autoconf" + + defJobs = str(numCPUs()) + defFwPrefix = '/Library/Frameworks' + + option_dict = { + "clean" : (False, "Clean all files from the build directory"), + "debug" : (False, "Build the library in debug symbols"), + "builddir" : ("", "Directory where the build will be performed for autoconf builds."), + "prefix" : ("", "Configured prefix to use for autoconf builds. Defaults to installdir if set. Ignored for framework builds."), + "jobs" : (defJobs, "Number of jobs to run at one time in make. Default: %s" % defJobs), + "install" : (False, "Install the toolkit to the installdir directory, or the default dir."), + "installdir" : ("", "Directory where built wxWidgets will be installed"), + "mac_distdir" : (None, "If set on Mac, will create an installer package in the specified dir."), + "mac_universal_binary" + : ("", "Comma separated list of architectures to include in the Mac universal binary"), + "mac_framework" : (False, "Install the Mac build as a framework"), + "mac_framework_prefix" + : (defFwPrefix, "Prefix where the framework should be installed. Default: %s" % defFwPrefix), + "cairo" : (False, "Enable dynamically loading the Cairo lib for wxGraphicsContext on MSW"), + "no_config" : (False, "Turn off configure step on autoconf builds"), + "config_only" : (False, "Only run the configure step and then exit"), + "rebake" : (False, "Regenerate Bakefile and autoconf files"), + "unicode" : (False, "Build the library with unicode support"), + "wxpython" : (False, "Build the wxWidgets library with all options needed by wxPython"), + "cocoa" : (False, "Build the old Mac Cocoa port."), + "osx_cocoa" : (False, "Build the new Cocoa port"), + "shared" : (False, "Build wx as a dynamic library"), + "extra_make" : ("", "Extra args to pass on [n]make's command line."), + "features" : ("", "A comma-separated list of wxUSE_XYZ defines on Win, or a list of configure flags on unix."), + "verbose" : (False, "Print commands as they are run, (to aid with debugging this script)"), + "jom" : (False, "Use jom.exe instead of nmake for MSW builds."), + } + + parser = optparse.OptionParser(usage="usage: %prog [options]", version="%prog 1.0") + + keys = option_dict.keys() + for opt in sorted(keys): + default = option_dict[opt][0] + action = "store" + if type(default) == bool: + action = "store_true" + parser.add_option("--" + opt, default=default, action=action, dest=opt, + help=option_dict[opt][1]) + + options, arguments = parser.parse_args(args=args) + + global verbose + if options.verbose: + verbose = True + + # compiler / build system specific args + buildDir = options.builddir + args = [] + installDir = options.installdir + prefixDir = options.prefix + + if toolkit == "autoconf": + if not buildDir: + buildDir = os.getcwd() + configure_opts = [] + if options.features != "": + configure_opts.extend(options.features.split(" ")) + + if options.unicode: + configure_opts.append("--enable-unicode") + + if options.debug: + configure_opts.append("--enable-debug") + + if options.cocoa: + configure_opts.append("--with-old_cocoa") + + if options.osx_cocoa: + configure_opts.append("--with-osx_cocoa") + + wxpy_configure_opts = [ + "--with-opengl", + "--enable-sound", + "--enable-graphics_ctx", + "--enable-mediactrl", + "--enable-display", + "--enable-geometry", + "--enable-debug_flag", + "--enable-optimise", + "--disable-debugreport", + "--enable-uiactionsim", + ] + + if sys.platform.startswith("darwin"): + wxpy_configure_opts.append("--enable-monolithic") + else: + wxpy_configure_opts.append("--with-sdl") + + # Try to use use lowest available SDK back to 10.5. Both Carbon and + # Cocoa builds require at least the 10.5 SDK now. We only add it to + # the wxpy options because this is a hard-requirement for wxPython, + # but other cases it is optional and is left up to the developer. + # TODO: there should be a command line option to set the SDK... + if sys.platform.startswith("darwin"): + for xcodePath in getXcodePaths(): + sdks = [ + xcodePath+"/SDKs/MacOSX10.5.sdk", + xcodePath+"/SDKs/MacOSX10.6.sdk", + xcodePath+"/SDKs/MacOSX10.7.sdk", + xcodePath+"/SDKs/MacOSX10.8.sdk", + ] + + # use the lowest available sdk + for sdk in sdks: + if os.path.exists(sdk): + wxpy_configure_opts.append( + "--with-macosx-sdk=%s" % sdk) + break + + if not options.mac_framework: + if installDir and not prefixDir: + prefixDir = installDir + if prefixDir: + prefixDir = os.path.abspath(prefixDir) + configure_opts.append("--prefix=" + prefixDir) + + + if options.wxpython: + configure_opts.extend(wxpy_configure_opts) + if options.debug: + # wxPython likes adding these debug options too + configure_opts.append("--enable-debug_gdb") + configure_opts.append("--disable-optimise") + configure_opts.remove("--enable-optimise") + + + if options.rebake: + retval = run("make -f autogen.mk") + exitIfError(retval, "Error running autogen.mk") + + if options.mac_framework: + # TODO: Should options.install be automatically turned on if the + # mac_framework flag is given? + + # framework builds always need to be monolithic + if not "--enable-monolithic" in configure_opts: + configure_opts.append("--enable-monolithic") + + # The --prefix given to configure will be the framework prefix + # plus the framework specific dir structure. + prefixDir = getPrefixInFramework(options) + configure_opts.append("--prefix=" + prefixDir) + + # the framework build adds symlinks above the installDir + prefixDir folder + # so we need to wipe from the framework root instead of inside the prefixDir. + frameworkRootDir = os.path.abspath(os.path.join(installDir + prefixDir, "..", "..")) + if os.path.exists(frameworkRootDir): + if os.path.exists(frameworkRootDir): + shutil.rmtree(frameworkRootDir) + + if options.mac_universal_binary: + if options.mac_universal_binary == 'default': + if options.osx_cocoa: + configure_opts.append("--enable-universal_binary=i386,x86_64") + else: + configure_opts.append("--enable-universal_binary") + else: + configure_opts.append("--enable-universal_binary=%s" % options.mac_universal_binary) + + + print("Configure options: " + repr(configure_opts)) + wxBuilder = builder.AutoconfBuilder() + if not options.no_config and not options.clean: + olddir = os.getcwd() + if buildDir: + os.chdir(buildDir) + exitIfError(wxBuilder.configure(dir=wxRootDir, options=configure_opts), + "Error running configure") + os.chdir(olddir) + + if options.config_only: + print("Exiting after configure") + return + + elif toolkit in ["msvc", "msvcProject"]: + flags = {} + buildDir = os.path.abspath(os.path.join(scriptDir, "..", "msw")) + + print("creating wx/msw/setup.h from setup0.h") + if options.unicode: + flags["wxUSE_UNICODE"] = "1" + + if options.cairo: + if not os.environ.get("CAIRO_ROOT"): + print("WARNING: Expected CAIRO_ROOT set in the environment!") + flags["wxUSE_CAIRO"] = "1" + + if options.wxpython: + flags["wxDIALOG_UNIT_COMPATIBILITY "] = "0" + flags["wxUSE_DEBUGREPORT"] = "0" + flags["wxUSE_DIALUP_MANAGER"] = "0" + flags["wxUSE_GRAPHICS_CONTEXT"] = "1" + flags["wxUSE_DISPLAY"] = "1" + flags["wxUSE_GLCANVAS"] = "1" + flags["wxUSE_POSTSCRIPT"] = "1" + flags["wxUSE_AFM_FOR_POSTSCRIPT"] = "0" + flags["wxUSE_DATEPICKCTRL_GENERIC"] = "1" + + # Remove this when Windows XP finally dies, or when there is a + # solution for ticket #13116... + flags["wxUSE_COMPILER_TLS"] = "0" + + if VERSION < (2,9): + flags["wxUSE_DIB_FOR_BITMAP"] = "1" + + if VERSION >= (2,9): + flags["wxUSE_UIACTIONSIMULATOR"] = "1" + + + mswIncludeDir = os.path.join(wxRootDir, "include", "wx", "msw") + setup0File = os.path.join(mswIncludeDir, "setup0.h") + setupText = open(setup0File, "rb").read() + + for flag in flags: + setupText, subsMade = re.subn(flag + "\s+?\d", "%s %s" % (flag, flags[flag]), setupText) + if subsMade == 0: + print("Flag %s wasn't found in setup0.h!" % flag) + sys.exit(1) + + setupFile = open(os.path.join(mswIncludeDir, "setup.h"), "wb") + setupFile.write(setupText) + setupFile.close() + args = [] + if toolkit == "msvc": + print("setting build options...") + args.append("-f makefile.vc") + if options.unicode: + args.append("UNICODE=1") + + if options.wxpython: + args.append("OFFICIAL_BUILD=1") + args.append("COMPILER_VERSION=%s" % getVisCVersion()) + args.append("SHARED=1") + args.append("MONOLITHIC=0") + args.append("USE_OPENGL=1") + args.append("USE_GDIPLUS=1") + + if not options.debug: + args.append("BUILD=release") + else: + args.append("BUILD=debug") + + if options.shared: + args.append("SHARED=1") + + if options.cairo: + args.append( + "CPPFLAGS=/I%s" % + os.path.join(os.environ.get("CAIRO_ROOT", ""), 'include\\cairo')) + + if options.jom: + nmakeCommand = 'jom.exe' + + wxBuilder = builder.MSVCBuilder(commandName=nmakeCommand) + + if toolkit == "msvcProject": + args = [] + if options.shared or options.wxpython: + args.append("wx_dll.dsw") + else: + args.append("wx.dsw") + + # TODO: + wxBuilder = builder.MSVCProjectBuilder() + + + if not wxBuilder: + print("Builder not available for your specified platform/compiler.") + sys.exit(1) + + if options.clean: + print("Performing cleanup.") + wxBuilder.clean(dir=buildDir, options=args) + + sys.exit(0) + + if options.extra_make: + args.append(options.extra_make) + + if not sys.platform.startswith("win"): + args.append("--jobs=" + options.jobs) + exitIfError(wxBuilder.build(dir=buildDir, options=args), "Error building") + + if options.install: + extra=None + if installDir: + extra = ['DESTDIR='+installDir] + wxBuilder.install(dir=buildDir, options=extra) + + if options.install and options.mac_framework: + + def renameLibrary(libname, frameworkname): + reallib = libname + links = [] + while os.path.islink(reallib): + links.append(reallib) + reallib = "lib/" + os.readlink(reallib) + + #print("reallib is %s" % reallib) + run("mv -f %s lib/%s.dylib" % (reallib, frameworkname)) + + for link in links: + run("ln -s -f %s.dylib %s" % (frameworkname, link)) + + frameworkRootDir = prefixDir + if installDir: + print("installDir = %s" % installDir) + frameworkRootDir = installDir + prefixDir + os.chdir(frameworkRootDir) + build_string = "" + if options.debug: + build_string = "d" + + fwname = getFrameworkName(options) + version = getoutput("bin/wx-config --release") + version_full = getoutput("bin/wx-config --version") + basename = getoutput("bin/wx-config --basename") + configname = getoutput("bin/wx-config --selected-config") + + os.makedirs("Resources") + wxplist = dict( + CFBundleDevelopmentRegion="English", + CFBundleIdentifier='org.wxwidgets.wxosxcocoa', + CFBundleName=fwname, + CFBundleVersion=version_full, + CFBundleExecutable=fwname, + CFBundleGetInfoString="%s %s" % (fwname, version_full), + CFBundlePackageType="FMWK", + CFBundleSignature="WXCO", + CFBundleShortVersionString=version_full, + CFBundleInfoDictionaryVersion="6.0", + ) + + import plistlib + plistlib.writePlist(wxplist, os.path.join(frameworkRootDir, "Resources", "Info.plist")) + + # we make wx the "actual" library file and link to it from libwhatever.dylib + # so that things can link to wx and survive minor version changes + renameLibrary("lib/lib%s-%s.dylib" % (basename, version), fwname) + run("ln -s -f lib/%s.dylib %s" % (fwname, fwname)) + + run("ln -s -f include Headers") + + for lib in ["GL", "STC", "Gizmos", "Gizmos_xrc"]: + libfile = "lib/lib%s_%s-%s.dylib" % (basename, lib.lower(), version) + if os.path.exists(libfile): + frameworkDir = "framework/wx%s/%s" % (lib, version) + if not os.path.exists(frameworkDir): + os.makedirs(frameworkDir) + renameLibrary(libfile, "wx" + lib) + run("ln -s -f ../../../%s %s/wx%s" % (libfile, frameworkDir, lib)) + + for lib in glob.glob("lib/*.dylib"): + if not os.path.islink(lib): + corelibname = "lib/lib%s-%s.0.dylib" % (basename, version) + run("install_name_tool -id %s %s" % (os.path.join(prefixDir, lib), lib)) + run("install_name_tool -change %s %s %s" % (os.path.join(frameworkRootDir, corelibname), os.path.join(prefixDir, corelibname), lib)) + + os.chdir("include") + + header_template = """ +#ifndef __WX_FRAMEWORK_HEADER__ +#define __WX_FRAMEWORK_HEADER__ + +%s + +#endif // __WX_FRAMEWORK_HEADER__ +""" + headers = "" + header_dir = "wx-%s/wx" % version + for include in glob.glob(header_dir + "/*.h"): + headers += "#include \n" + + framework_header = open("%s.h" % fwname, "w") + framework_header.write(header_template % headers) + framework_header.close() + + run("ln -s -f %s wx" % header_dir) + os.chdir("wx-%s/wx" % version) + run("ln -s -f ../../../lib/wx/include/%s/wx/setup.h setup.h" % configname) + + os.chdir(os.path.join(frameworkRootDir, "..")) + run("ln -s -f %s Current" % getWxRelease()) + os.chdir("..") + run("ln -s -f Versions/Current/Headers Headers") + run("ln -s -f Versions/Current/Resources Resources") + run("ln -s -f Versions/Current/%s %s" % (fwname, fwname)) + + # sanity check to ensure the symlink works + os.chdir("Versions/Current") + + # put info about the framework into wx-config + os.chdir(frameworkRootDir) + text = file('lib/wx/config/%s' % configname).read() + text = text.replace("MAC_FRAMEWORK=", "MAC_FRAMEWORK=%s" % getFrameworkName(options)) + if options.mac_framework_prefix not in ['/Library/Frameworks', + '/System/Library/Frameworks']: + text = text.replace("MAC_FRAMEWORK_PREFIX=", + "MAC_FRAMEWORK_PREFIX=%s" % options.mac_framework_prefix) + file('lib/wx/config/%s' % configname, 'w').write(text) + + # The framework is finished! + print("wxWidgets framework created at: " + + os.path.join( installDir, + options.mac_framework_prefix, + '%s.framework' % fwname)) + + + # adjust the install_name if needed + if sys.platform.startswith("darwin") and \ + options.install and \ + options.installdir and \ + not options.mac_framework and \ + not options.wxpython: # wxPython's build will do this later if needed + if not prefixDir: + prefixDir = '/usr/local' + macFixupInstallNames(options.installdir, prefixDir)#, buildDir) + + # make a package if a destdir was set. + if options.mac_framework and \ + options.install and \ + options.installdir and \ + options.mac_distdir: + + if os.path.exists(options.mac_distdir): + shutil.rmtree(options.mac_distdir) + + packagedir = os.path.join(options.mac_distdir, "packages") + os.makedirs(packagedir) + basename = os.path.basename(prefixDir.split(".")[0]) + packageName = basename + "-" + getWxRelease() + packageMakerPath = getXcodePaths()[0]+"/usr/bin/packagemaker " + args = [] + args.append("--root %s" % options.installdir) + args.append("--id org.wxwidgets.%s" % basename.lower()) + args.append("--title %s" % packageName) + args.append("--version %s" % getWxRelease()) + args.append("--out %s" % os.path.join(packagedir, packageName + ".pkg")) + cmd = packageMakerPath + ' '.join(args) + print("cmd = %s" % cmd) + run(cmd) + + os.chdir(options.mac_distdir) + + run('hdiutil create -srcfolder %s -volname "%s" -imagekey zlib-level=9 %s.dmg' % (packagedir, packageName, packageName)) + + shutil.rmtree(packagedir) + +if __name__ == '__main__': + exitWithException = False # use sys.exit instead + main(sys.argv[0], sys.argv[1:]) + diff --git a/build/tools/builder.py b/build/tools/builder.py new file mode 100755 index 0000000000..22a30469ae --- /dev/null +++ b/build/tools/builder.py @@ -0,0 +1,255 @@ +import os +import subprocess +import sys +import time + +class BuildError(Exception): + def __init__(self, value): + self.value = value + + def __repr__(self): + return repr(self.value) + +def runInDir(command, dir=None, verbose=True): + if dir: + olddir = os.getcwd() + os.chdir(dir) + + commandStr = " ".join(command) + if verbose: + print(commandStr) + result = os.system(commandStr) + + if dir: + os.chdir(olddir) + + return result + +class Builder: + """ + Base class exposing the Builder interface. + """ + + def __init__(self, formatName="", commandName="", programDir=None): + """ + formatName = human readable name for project format (should correspond with Bakefile names) + commandName = name of command line program used to invoke builder + programDir = directory program is located in, if not on the path + """ + + self.dir = dir + self.name = commandName + self.formatName = formatName + self.programDir = programDir + self.doSetup() + + def doSetup(self): + """ + Do anything special needed to configure the environment to build with this builder. + """ + + pass + + def isAvailable(self): + """ + Run sanity checks before attempting to build with this format + """ + # Make sure the builder program exists + programPath = self.getProgramPath() + if os.path.exists(programPath): + return True + else: + # check the PATH for the program + # TODO: How do we check if we're in Cygwin? + if sys.platform.startswith("win"): + result = os.system(self.name) + if result == 0: + return True + dirs = os.environ["PATH"].split(":") + + for dir in dirs: + if os.path.isfile(os.path.join(dir, self.name)): + return True + + else: + result = os.system("which %s" % self.name) + + if result == 0: + return True + + return False + + def getProgramPath(self): + if self.programDir: + path = os.path.join(self.programDir, self.name) + if sys.platform.startswith("win"): + path = '"%s"' % path + return path + + return self.name + + def getProjectFileArg(self, projectFile = None): + result = [] + if projectFile: + result.append(projectFile) + return result + + def clean(self, dir=None, projectFile=None, options=[]): + """ + dir = the directory containing the project file + projectFile = Some formats need to explicitly specify the project file's name + """ + if self.isAvailable(): + args = [self.getProgramPath()] + pfArg = self.getProjectFileArg(projectFile) + if pfArg: + args.extend(pfArg) + args.append("clean") + if options: + args.extend(options) + result = runInDir(args, dir) + return result + + return False + + def configure(self, dir=None, options=[]): + # if we don't have configure, just report success + return 0 + + def build(self, dir=None, projectFile=None, targets=None, options=[]): + if self.isAvailable(): + args = [self.getProgramPath()] + pfArg = self.getProjectFileArg(projectFile) + if pfArg: + args.extend(pfArg) + # Important Note: if extending args, check it first! + # NoneTypes are not iterable and will crash the clean, build, or install! + # Very very irritating when this happens right at the end. + if options: + args.extend(options) + result = runInDir(args, dir) + return result + + return 1 + + def install(self, dir=None, projectFile=None, options=[]): + if self.isAvailable(): + args = [self.getProgramPath()] + pfArg = self.getProjectFileArg(projectFile) + if pfArg: + args.extend(pfArg) + args.append("install") + if options: + args.extend(options) + result = runInDir(args, dir) + return result + + return 1 + + +# Concrete subclasses of abstract Builder interface + +class GNUMakeBuilder(Builder): + def __init__(self, commandName="make", formatName="GNUMake"): + Builder.__init__(self, commandName=commandName, formatName=formatName) + + +class XcodeBuilder(Builder): + def __init__(self, commandName="xcodebuild", formatName="Xcode"): + Builder.__init__(self, commandName=commandName, formatName=formatName) + + +class AutoconfBuilder(GNUMakeBuilder): + def __init__(self, formatName="autoconf"): + GNUMakeBuilder.__init__(self, formatName=formatName) + + def configure(self, dir=None, options=None): + #olddir = os.getcwd() + #os.chdir(dir) + + configdir = dir + if not dir: + configdir = os.getcwd() + + configure_cmd = "" + while os.path.exists(configdir): + config_cmd = os.path.join(configdir, "configure") + if not os.path.exists(config_cmd): + parentdir = os.path.abspath(os.path.join(configdir, "..")) + if configdir == parentdir: + break + + configdir = parentdir + else: + configure_cmd = config_cmd + break + + if not configure_cmd: + sys.stderr.write("Could not find configure script at %r. Have you run autoconf?\n" % dir) + return 1 + + optionsStr = " ".join(options) if options else "" + command = "%s %s" % (configure_cmd, optionsStr) + print(command) + result = os.system(command) + #os.chdir(olddir) + return result + + +class MSVCBuilder(Builder): + def __init__(self, commandName="nmake.exe"): + Builder.__init__(self, commandName=commandName, formatName="msvc") + + def isAvailable(self): + PATH = os.environ['PATH'].split(os.path.pathsep) + for p in PATH: + if os.path.exists(os.path.join(p, self.name)): + return True + return False + + def getProjectFileArg(self, projectFile = None): + result = [] + if projectFile: + result.extend(['-f', projectFile]) + + return result + + +class MSVCProjectBuilder(Builder): + def __init__(self): + Builder.__init__(self, commandName="VCExpress.exe", formatName="msvcProject") + for key in ["VS90COMNTOOLS", "VC80COMNTOOLS", "VC71COMNTOOLS"]: + if os.environ.has_key(key): + self.programDir = os.path.join(os.environ[key], "..", "IDE") + + if self.programDir == None: + for version in ["9.0", "8", ".NET 2003"]: + msvcDir = "C:\\Program Files\\Microsoft Visual Studio %s\\Common7\\IDE" % version + if os.path.exists(msvcDir): + self.programDir = msvcDir + + def isAvailable(self): + if self.programDir: + path = os.path.join(self.programDir, self.name) + if os.path.exists(path): + return True + else: + # I don't have commercial versions of MSVC so I can't test this + name = "devenv.com" + path = os.path.join(self.programDir, name) + if os.path.exists(path): + self.name = "devenv.com" + return True + + return False + +builders = [GNUMakeBuilder, XcodeBuilder, AutoconfBuilder, MSVCBuilder, MSVCProjectBuilder] + +def getAvailableBuilders(): + availableBuilders = {} + for symbol in builders: + thisBuilder = symbol() + if thisBuilder.isAvailable(): + availableBuilders[thisBuilder.formatName] = symbol + + return availableBuilders