2f90df854e
2. the C++ versions of wxSizer and firends, Python versions are 'depreciated' 3. wxPyEvent and wxPyCommandEvent, event classes that can carry some python objects through the event system and safely come back out again. 4. wxGridSizer and wxFlexGridSizer 5. wxValidator 6. wxPyOnDemandOutputWindow 7. several tweaks, fixes and additions of missing methods, etc. 8. and probably several other things I am forgetting since CVS was down so long... git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3758 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
783 lines
24 KiB
Python
Executable File
783 lines
24 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#----------------------------------------------------------------------------
|
|
# Name: build.py
|
|
# Purpose: This script is used to build wxPython. It reads a build
|
|
# configuration file in the requested project directory and
|
|
# based on the contents of the file can build Makefiles for
|
|
# unix or win32, and can execute make with various options
|
|
# potentially automating the entire build/install/clean process
|
|
# from a single command.
|
|
#
|
|
# Author: Robin Dunn
|
|
#
|
|
# Created: 18-Aug-1999
|
|
# RCS-ID: $Id$
|
|
# Copyright: (c) 1999 by Total Control Software
|
|
# Licence: wxWindows license
|
|
#----------------------------------------------------------------------------
|
|
"""
|
|
build.py
|
|
|
|
This script is used to build wxPython. It reads a build configuration
|
|
file in the requested project directory and based on the contents of
|
|
the file can build Makefiles for unix or win32, and can execute make
|
|
with various options potentially automating the entire
|
|
build/install/clean process from a single command.
|
|
|
|
The default action is to build the Makefile and exit.
|
|
|
|
Options
|
|
-C dir CD to dir before doing anything
|
|
-B file Use file as the build configuration (default ./build.cfg)
|
|
-M file Use file as the name of the makefile to create
|
|
(default Makefile)
|
|
|
|
-b Build the module (runs make)
|
|
-i Install the module (runs make install)
|
|
-c Cleanup (runs make clean)
|
|
-u Uninstall (runs make uninstall)
|
|
|
|
-h Show help and exit
|
|
|
|
|
|
Configuration Files
|
|
|
|
The build configuration file lists targets, source files and options
|
|
for the the build process. The contents of the build.cfg are used to
|
|
dynamically generate the Makefile.
|
|
|
|
To prevent you from getting screwed when the default build.cfg is
|
|
updated, you can override the values in build.cfg by putting your
|
|
custom definitions in a file named build.local. You can also place a
|
|
build.local file in the parent directory, or even in the grandparent
|
|
directory for project-wide overrides. Finally, command-line arguments
|
|
of the form NAME=VALUE can also be used to override simple configuration
|
|
values. The order of evaluation is:
|
|
|
|
0. comman-line flags (-M, -b, etc.)
|
|
1. ./build.cfg
|
|
2. ../../build.local (if present)
|
|
3. ../build.local (if present)
|
|
4. ./build.local (if present)
|
|
5. command-line NAME=VALUEs
|
|
|
|
The config files are actually just Python files that get exec'ed in a
|
|
separate namespace which is then used later as a configuration object.
|
|
This keeps the build script simple in that it doesn't have to parse
|
|
anything, and the config files can be much more than just names and
|
|
values as pretty much any python code can be executed. The global
|
|
variables set in the config namespace are what are used later as
|
|
configuation values.
|
|
|
|
|
|
Configuration Options
|
|
|
|
The following variables can be set in the config files. Only a few are
|
|
required, the rest will either have suitable defaults or will be
|
|
calculated from your current Python runtime environment.
|
|
|
|
MODULE The name of the extension module to produce
|
|
SWIGFILES A list of files that should be run through SWIG
|
|
SWIGFLAGS Flags for SWIG
|
|
SOURCES Other C/C++ sources that should be part of the module
|
|
PYFILES Other Python files that should be installed with the module
|
|
CFLAGS Flags to be used by the compiler
|
|
LFLAGS Flags to be used at the link step
|
|
LIBS Libraries to be linked with
|
|
|
|
OTHERCFLAGS Extra flags to append to CFLAGS
|
|
OTHERLFLAGS Extra flags to append to LFLAGS
|
|
OTHERSWIGFLAGS Extra flags to append to SWIGFLAGS
|
|
OTHERLIBS Other libraries to be linked with, in addition to LIBS
|
|
OTHERTARGETS Other targets to be placed on the default rule line
|
|
OTHERINSTALLTARGETS
|
|
Other targets to be placed on the install rule line
|
|
OTHERRULES This text is placed at the end of the makefile and
|
|
will typically be used for adding rules and such
|
|
DEFAULTRULE Text to be used for the default rule in the makefile
|
|
|
|
TARGETDIR Destination for the install step
|
|
|
|
MAKE The make program to use
|
|
MAKEFILE The name of the makefile
|
|
|
|
runBuild Setting this to 1 is eqivalent to the -b flag
|
|
runInstall Setting this to 1 is eqivalent to the -i flag
|
|
runClean Setting this to 1 is eqivalent to the -c flag
|
|
runUninstall Setting this to 1 is eqivalent to the -u flag
|
|
|
|
PYVERSION Version number of Python used in pathnames
|
|
PYPREFIX The root of the Python install
|
|
EXECPREFIX The root of the Python install for binary files
|
|
PYTHONLIB The Python link library
|
|
|
|
"""
|
|
|
|
import sys, os, string, getopt
|
|
|
|
#----------------------------------------------------------------------------
|
|
# This is really the wxPython version number, and will be placed in the
|
|
# Makefiles for use with the distribution related targets.
|
|
|
|
__version__ = '2.1.4'
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
def main(args):
|
|
try:
|
|
opts, args = getopt.getopt(args[1:], 'C:B:M:bicu')
|
|
except getopt.error:
|
|
usage()
|
|
sys.exit(1)
|
|
|
|
if not os.environ.has_key('WXWIN'):
|
|
print "WARNING: WXWIN is not set in the environment. WXDIR may not\n"\
|
|
" be set properly in the makefile, you will have to \n"\
|
|
" set the environment variable or override in build.local."
|
|
|
|
bldCfg = 'build.cfg'
|
|
bldCfgLocal = 'build.local'
|
|
MAKEFILE = 'Makefile'
|
|
runBuild = 0
|
|
runInstall = 0
|
|
runClean = 0
|
|
runUninstall = 0
|
|
|
|
for flag, value in opts:
|
|
if flag == '-C': os.chdir(value)
|
|
elif flag == '-B': bldCfgFile = value
|
|
elif flag == '-M': makefile = value
|
|
elif flag == '-b': runBuild = 1
|
|
elif flag == '-c': runClean = 1
|
|
elif flag == '-i': runInstall = 1
|
|
elif flag == '-u': runUninstall = 1
|
|
|
|
elif flag == '-h': usage(); sys.exit(1)
|
|
else: usage(); sys.exit(1)
|
|
|
|
config = BuildConfig(bldCfg = bldCfg,
|
|
bldCfgLocal = bldCfgLocal,
|
|
MAKEFILE = MAKEFILE,
|
|
runBuild = runBuild,
|
|
runInstall = runInstall,
|
|
runClean = runClean,
|
|
runUninstall = runUninstall)
|
|
|
|
err = 0
|
|
if config.readConfigFiles(args):
|
|
config.doFixups()
|
|
config.makeMakefile()
|
|
|
|
if config.runBuild:
|
|
cmd = "%s -f %s" % (config.MAKE, config.MAKEFILE)
|
|
print "Running:", cmd
|
|
err = os.system(cmd)
|
|
|
|
if not err and config.runInstall:
|
|
cmd = "%s -f %s install" % (config.MAKE, config.MAKEFILE)
|
|
print "Running:", cmd
|
|
err = os.system(cmd)
|
|
|
|
|
|
if not err and config.runClean:
|
|
cmd = "%s -f %s clean" % (config.MAKE, config.MAKEFILE)
|
|
print "Running:", cmd
|
|
err = os.system(cmd)
|
|
|
|
if not err and config.runUninstall:
|
|
cmd = "%s -f %s uninstall" % (config.MAKE, config.MAKEFILE)
|
|
print "Running:", cmd
|
|
err = os.system(cmd)
|
|
|
|
return err
|
|
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
def usage():
|
|
print __doc__
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
def swapslash(st):
|
|
if sys.platform != 'win32':
|
|
st = string.join(string.split(st, '\\'), '/')
|
|
return st
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
def splitlines(st):
|
|
return string.join(string.split(string.strip(st), ' '), ' \\\n\t')
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
class BuildConfig:
|
|
def __init__(self, **kw):
|
|
self.__dict__.update(kw)
|
|
self.setDefaults()
|
|
|
|
#------------------------------------------------------------
|
|
def setDefaults(self):
|
|
self.VERSION = __version__
|
|
self.MODULE = ''
|
|
self.SWIGFILES = []
|
|
self.SWIGFLAGS = '-c++ -shadow -python -keyword -dnone -I$(WXPSRCDIR)'
|
|
self.SOURCES = []
|
|
self.PYFILES = []
|
|
self.LFLAGS = ''
|
|
self.OTHERCFLAGS = ''
|
|
self.OTHERLFLAGS = ''
|
|
self.OTHERSWIGFLAGS = ''
|
|
self.OTHERLIBS = ''
|
|
self.OTHERTARGETS = ''
|
|
self.OTHERINSTALLTARGETS = ''
|
|
self.OTHERUNINSTALLTARGETS = ''
|
|
self.OTHERRULES = ''
|
|
self.DEFAULTRULE = 'default: $(GENCODEDIR) $(TARGET)'
|
|
self.PYVERSION = sys.version[:3]
|
|
self.PYPREFIX = sys.prefix
|
|
self.EXECPREFIX = sys.exec_prefix
|
|
self.WXDIR = '$(WXWIN)'
|
|
self.FINAL = '0'
|
|
self.WXP_USE_THREAD = '1'
|
|
self.WXUSINGDLL = '1'
|
|
self.OTHERDEP = ''
|
|
self.WXPSRCDIR = '$(WXDIR)/utils/wxPython/src'
|
|
self.SWIGDEPS = ''
|
|
self.OTHERDEPS = ''
|
|
|
|
|
|
if sys.platform == 'win32':
|
|
self.MAKE = 'nmake'
|
|
self.PYTHONLIB = '$(PYPREFIX)\\libs\\python15.lib'
|
|
self.TARGETDIR = '$(PYPREFIX)\\wxPython'
|
|
self.LIBS = '$(PYTHONLIB) $(WXPSRCDIR)\wxc.lib'
|
|
self.GENCODEDIR = 'msw'
|
|
self.SWIGTOOLKITFLAG = '-D__WXMSW__'
|
|
self.OBJEXT = '.obj'
|
|
self.TARGET = '$(MODULE).pyd'
|
|
self.CFLAGS = '-I$(PYPREFIX)\include -I$(WXPSRCDIR) -I. /Fp$(MODULE).pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H $(THREAD) '
|
|
self.LFLAGS = '$(DEBUGLFLAGS) /DLL /subsystem:windows,3.50 /machine:I386 /nologo'
|
|
self.RESFILE = ''
|
|
self.RESRULE = ''
|
|
self.OVERRIDEFLAGS = '/GX-'
|
|
self.RMCMD = '-erase '
|
|
self.WXPSRCDIR = os.path.normpath(self.WXPSRCDIR)
|
|
|
|
|
|
else:
|
|
self.MAKE = 'make'
|
|
self.PYLIB = '$(EXECPREFIX)/lib/python$(PYVERSION)'
|
|
self.LIBPL = '$(PYLIB)/config'
|
|
self.PYTHONLIB = '$(LIBPL)/libpython$(PYVERSION).a'
|
|
self.TARGETDIR = '$(EXECPREFIX)/lib/python$(PYVERSION)/site-packages/wxPython'
|
|
self.TARGET = '$(MODULE)module$(SO)'
|
|
self.OBJEXT = '.o'
|
|
self.HELPERLIB = 'wxPyHelpers'
|
|
self.HELPERLIBDIR = '/usr/local/lib'
|
|
self.CFLAGS = '-DSWIG_GLOBAL -DHAVE_CONFIG_H $(THREAD) -I. '\
|
|
'`wx-config --cflags` -I$(PYINCLUDE) -I$(EXECINCLUDE) '\
|
|
'-I$(WXPSRCDIR)'
|
|
self.LFLAGS = '-L$(WXPSRCDIR) `wx-config --libs`'
|
|
self.LIBS = '-l$(HELPERLIB)'
|
|
self.RMCMD = '-rm -f '
|
|
|
|
# **** What to do when I start supporting Motif, etc.???
|
|
self.GENCODEDIR = 'gtk'
|
|
self.SWIGTOOLKITFLAG = '-D__WXGTK__'
|
|
|
|
# Extract a few things from Python's Makefile...
|
|
try:
|
|
filename = os.path.join(self.EXECPREFIX,
|
|
'lib/python'+self.PYVERSION,
|
|
'config/Makefile')
|
|
mfText = string.split(open(filename, 'r').read(), '\n')
|
|
except IOError:
|
|
raise SystemExit, "Python development files not found"
|
|
|
|
self.CCC = self.findMFValue(mfText, 'CCC')
|
|
self.CC = self.findMFValue(mfText, 'CC')
|
|
self.OPT = self.findMFValue(mfText, 'OPT')
|
|
self.SO = self.findMFValue(mfText, 'SO')
|
|
self.LDSHARED = self.findMFValue(mfText, 'LDSHARED')
|
|
self.CCSHARED = self.findMFValue(mfText, 'CCSHARED')
|
|
#self.LINKFORSHARED = self.findMFValue(mfText, 'LINKFORSHARED')
|
|
#self. = self.findMFValue(mfText, '')
|
|
#self. = self.findMFValue(mfText, '')
|
|
|
|
|
|
# The majority of cases will require LDSHARED to be
|
|
# modified to use the C++ driver instead of the C driver
|
|
# for linking. We'll try to do it here and if we goof up
|
|
# then the user can correct it in their build.local file.
|
|
self.LDSHARED = string.join(['$(CCC)'] +
|
|
string.split(self.LDSHARED, ' ')[1:],
|
|
' ')
|
|
|
|
|
|
#------------------------------------------------------------
|
|
def doFixups(self):
|
|
# This is called after the config files have been evaluated
|
|
# so we can do some sanity checking...
|
|
if sys.platform != 'win32':
|
|
if not self.CCC:
|
|
print "Warning: C++ compiler not specified (CCC). Assuming c++"
|
|
self.CCC = 'c++'
|
|
if not self.CC:
|
|
print "Warning: C compiler not specified (CC). Assuming cc"
|
|
self.CC = 'cc'
|
|
|
|
#------------------------------------------------------------
|
|
def findMFValue(self, mfText, st):
|
|
# Find line begining with st= and return the value
|
|
# Regex would probably be to cooler way to do this, but
|
|
# I think this is the most understandable.
|
|
for line in mfText:
|
|
if string.find(line, st+'=') == 0:
|
|
st = string.strip(line[len(st)+1:])
|
|
return st
|
|
return None
|
|
|
|
#------------------------------------------------------------
|
|
def makeMakefile(self):
|
|
|
|
# make a list of object file names
|
|
objects = ""
|
|
for name in self.SWIGFILES:
|
|
objects = objects + os.path.splitext(name)[0] + self.OBJEXT + ' '
|
|
for name in self.SOURCES:
|
|
obj = os.path.basename(name)
|
|
objects = objects + os.path.splitext(obj)[0] + self.OBJEXT + ' '
|
|
self.OBJECTS = splitlines(objects)
|
|
|
|
|
|
# now build the text for the dependencies
|
|
depends = ""
|
|
for name in self.SWIGFILES:
|
|
rootname = os.path.splitext(name)[0]
|
|
text = '$(GENCODEDIR)/%s.cpp $(GENCODEDIR)/%s.py : %s.i %s\n' \
|
|
'$(TARGETDIR)\\%s.py : $(GENCODEDIR)\\%s.py\n' % \
|
|
(rootname, rootname, rootname, self.SWIGDEPS, rootname, rootname)
|
|
depends = depends + text
|
|
if self.OTHERDEPS:
|
|
text = '%s%s : %s\n' % \
|
|
(os.path.splitext(name)[0], self.OBJEXT, self.OTHERDEPS)
|
|
depends = depends + text
|
|
for name in self.PYFILES:
|
|
text = '$(TARGETDIR)\\%s.py : %s.py\n' % \
|
|
tuple([os.path.splitext(name)[0]] * 2)
|
|
depends = depends + text
|
|
if self.OTHERDEPS:
|
|
for name in self.SOURCES:
|
|
name = os.path.basename(name)
|
|
text = '%s%s : %s\n' % \
|
|
(os.path.splitext(name)[0], self.OBJEXT, self.OTHERDEPS)
|
|
depends = depends + text
|
|
|
|
self.DEPENDS = swapslash(depends)
|
|
|
|
|
|
# and the list of .py files
|
|
pymodules = ""
|
|
for name in self.SWIGFILES:
|
|
pymodules = pymodules + '$(TARGETDIR)\\%s.py ' % os.path.splitext(name)[0]
|
|
for name in self.PYFILES:
|
|
pymodules = pymodules + '$(TARGETDIR)\\%s.py ' % os.path.splitext(name)[0]
|
|
self.PYMODULES = splitlines(swapslash(pymodules))
|
|
|
|
|
|
# now make a list of the python files that would need uninstalled
|
|
pycleanup = ""
|
|
for name in self.SWIGFILES:
|
|
pycleanup = pycleanup + self.makeCleanupList(name)
|
|
for name in self.PYFILES:
|
|
pycleanup = pycleanup + self.makeCleanupList(name)
|
|
self.PYCLEANUP = swapslash(pycleanup)
|
|
|
|
|
|
# finally, build the makefile
|
|
if sys.platform == 'win32':
|
|
if self.RESFILE:
|
|
self.RESFILE = '$(MODULE).res'
|
|
self.RESRULE = '$(MODULE).res : $(MODULE).rc $(WXDIR)\\include\\wx\\msw\\wx.rc\n\t'\
|
|
'$(rc) -r /i$(WXDIR)\\include -fo$@ $(MODULE).rc'
|
|
text = win32Template % self.__dict__
|
|
else:
|
|
text = unixTemplate % self.__dict__
|
|
f = open(self.MAKEFILE, 'w')
|
|
f.write(text)
|
|
f.close()
|
|
|
|
print "Makefile created: ", self.MAKEFILE
|
|
|
|
|
|
|
|
#------------------------------------------------------------
|
|
def makeCleanupList(self, name):
|
|
st = ""
|
|
st = st + '\t%s$(TARGETDIR)\\%s.py\n' % (self.RMCMD, os.path.splitext(name)[0])
|
|
st = st + '\t%s$(TARGETDIR)\\%s.pyc\n' % (self.RMCMD, os.path.splitext(name)[0])
|
|
st = st + '\t%s$(TARGETDIR)\\%s.pyo\n' % (self.RMCMD, os.path.splitext(name)[0])
|
|
return st
|
|
|
|
|
|
#------------------------------------------------------------
|
|
def readConfigFiles(self, args):
|
|
return self.processFile(self.bldCfg, 1) and \
|
|
self.processFile(os.path.join('../..', self.bldCfgLocal)) and \
|
|
self.processFile(os.path.join('..', self.bldCfgLocal)) and \
|
|
self.processFile(os.path.join('.', self.bldCfgLocal)) and \
|
|
self.processArgs(args)
|
|
|
|
#------------------------------------------------------------
|
|
def processFile(self, filename, required=0):
|
|
try:
|
|
text = open(filename, 'r').read()
|
|
except IOError:
|
|
if required:
|
|
print "Unable to open %s" % filename
|
|
return 0
|
|
else:
|
|
return 1
|
|
|
|
try:
|
|
exec(text, self.__dict__)
|
|
except:
|
|
print "Error evaluating %s" % filename
|
|
import traceback
|
|
traceback.print_exc()
|
|
return 0
|
|
return 1
|
|
|
|
|
|
#------------------------------------------------------------
|
|
def processArgs(self, args):
|
|
try:
|
|
for st in args:
|
|
pair = string.split(st, '=')
|
|
name = pair[0]
|
|
value = pair[1]
|
|
self.__dict__[name] = value
|
|
except:
|
|
print "Error parsing command-line: %s" % st
|
|
return 0
|
|
|
|
return 1
|
|
|
|
|
|
#------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
#----------------------------------------------------------------------------
|
|
#----------------------------------------------------------------------------
|
|
#----------------------------------------------------------------------------
|
|
|
|
win32Template = '''
|
|
#----------------------------------------------------------------------
|
|
# This makefile was autogenerated from build.py. Your changes will be
|
|
# lost if the generator is run again. You have been warned.
|
|
#----------------------------------------------------------------------
|
|
|
|
WXDIR = %(WXDIR)s
|
|
VERSION = %(VERSION)s
|
|
MODULE = %(MODULE)s
|
|
SWIGFLAGS = %(SWIGFLAGS)s %(SWIGTOOLKITFLAG)s %(OTHERSWIGFLAGS)s
|
|
CFLAGS = %(CFLAGS)s
|
|
LFLAGS = %(LFLAGS)s
|
|
PYVERSION = %(PYVERSION)s
|
|
PYPREFIX = %(PYPREFIX)s
|
|
EXECPREFIX = %(EXECPREFIX)s
|
|
PYTHONLIB = %(PYTHONLIB)s
|
|
FINAL = %(FINAL)s
|
|
WXP_USE_THREAD = %(WXP_USE_THREAD)s
|
|
WXUSINGDLL = %(WXUSINGDLL)s
|
|
GENCODEDIR = %(GENCODEDIR)s
|
|
RESFILE = %(RESFILE)s
|
|
WXPSRCDIR = %(WXPSRCDIR)s
|
|
|
|
|
|
TARGETDIR = %(TARGETDIR)s
|
|
|
|
OBJECTS = %(OBJECTS)s
|
|
PYMODULES = %(PYMODULES)s
|
|
TARGET = %(TARGET)s
|
|
|
|
|
|
|
|
|
|
!if "$(FINAL)" == "0"
|
|
DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES
|
|
!else
|
|
DEBUGLFLAGS = /INCREMENTAL:NO
|
|
!endif
|
|
!if "$(WXP_USE_THREAD)" == "1"
|
|
THREAD=-DWXP_USE_THREAD=1
|
|
!endif
|
|
|
|
|
|
|
|
|
|
NOPCH=1
|
|
OVERRIDEFLAGS=%(OVERRIDEFLAGS)s
|
|
EXTRAFLAGS = $(CFLAGS) %(OTHERCFLAGS)s
|
|
|
|
LFLAGS = %(LFLAGS)s %(OTHERLFLAGS)s
|
|
EXTRALIBS = %(LIBS)s %(OTHERLIBS)s
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
!include $(WXDIR)\\src\\makevc.env
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
%(DEFAULTRULE)s %(OTHERTARGETS)s
|
|
|
|
|
|
|
|
install: $(TARGETDIR) $(TARGETDIR)\\$(TARGET) pycfiles %(OTHERINSTALLTARGETS)s
|
|
|
|
clean:
|
|
-erase *.obj
|
|
-erase *.exe
|
|
-erase *.res
|
|
-erase *.map
|
|
-erase *.sbr
|
|
-erase *.pdb
|
|
-erase *.pch
|
|
-erase $(MODULE).exp
|
|
-erase $(MODULE).lib
|
|
-erase $(MODULE).ilk
|
|
-erase $(TARGET)
|
|
|
|
|
|
uninstall: %(OTHERUNINSTALLTARGETS)s
|
|
-erase $(TARGETDIR)\\$(TARGET)
|
|
%(PYCLEANUP)s
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
# implicit rule for compiling .cpp and .c files
|
|
{}.cpp{}.obj:
|
|
$(cc) @<<
|
|
$(CPPFLAGS) /c /Tp $<
|
|
<<
|
|
|
|
{$(GENCODEDIR)}.cpp{}.obj:
|
|
$(cc) @<<
|
|
$(CPPFLAGS) /c /Tp $<
|
|
<<
|
|
|
|
{}.c{}.obj:
|
|
$(cc) @<<
|
|
$(CPPFLAGS) /c $<
|
|
<<
|
|
|
|
.SUFFIXES : .i .py
|
|
|
|
# Implicit rules to run SWIG
|
|
{}.i{$(GENCODEDIR)}.cpp:
|
|
swig $(SWIGFLAGS) -c -o $@ $<
|
|
|
|
{}.i{$(GENCODEDIR)}.py:
|
|
swig $(SWIGFLAGS) -c -o $(GENCODEDIR)\\tmp_wrap.cpp $<
|
|
-erase $(GENCODEDIR)\\tmp_wrap.cpp
|
|
|
|
|
|
{$(GENCODEDIR)}.py{$(TARGETDIR)}.py:
|
|
copy $< $@
|
|
|
|
{}.py{$(TARGETDIR)}.py:
|
|
copy $< $@
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
$(TARGET) : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(RESFILE)
|
|
$(link) @<<
|
|
/out:$@
|
|
$(LFLAGS) /def:$(MODULE).def /implib:./$(MODULE).lib
|
|
$(DUMMYOBJ) $(OBJECTS) $(RESFILE)
|
|
$(LIBS)
|
|
<<
|
|
|
|
|
|
%(RESRULE)s
|
|
|
|
|
|
$(TARGETDIR)\\$(TARGET) : $(TARGET)
|
|
copy $(TARGET) $@
|
|
|
|
|
|
pycfiles : $(PYMODULES)
|
|
$(EXECPREFIX)\\python $(PYPREFIX)\\Lib\\compileall.py -l $(TARGETDIR)
|
|
$(EXECPREFIX)\\python -O $(PYPREFIX)\Lib\\compileall.py -l $(TARGETDIR)
|
|
|
|
|
|
$(TARGETDIR) :
|
|
mkdir $(TARGETDIR)
|
|
|
|
$(GENCODEDIR):
|
|
mkdir $(GENCODEDIR)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
%(DEPENDS)s
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
showflags:
|
|
@echo CPPFLAGS:
|
|
@echo $(CPPFLAGS)
|
|
@echo LFLAGS:
|
|
@echo $(LFLAGS)
|
|
|
|
|
|
|
|
%(OTHERRULES)s
|
|
'''
|
|
|
|
#----------------------------------------------------------------------------
|
|
#----------------------------------------------------------------------------
|
|
#----------------------------------------------------------------------------
|
|
|
|
unixTemplate = '''
|
|
#----------------------------------------------------------------------
|
|
# This makefile was autogenerated from build.py. Your changes will be
|
|
# lost if the generator is run again. You have been warned.
|
|
#----------------------------------------------------------------------
|
|
|
|
|
|
|
|
WXDIR = %(WXDIR)s
|
|
VERSION = %(VERSION)s
|
|
MODULE = %(MODULE)s
|
|
SWIGFLAGS = %(SWIGFLAGS)s %(SWIGTOOLKITFLAG)s %(OTHERSWIGFLAGS)s
|
|
CFLAGS = %(CFLAGS)s $(OPT) %(OTHERCFLAGS)s
|
|
LFLAGS = %(LFLAGS)s %(OTHERLFLAGS)s
|
|
LIBS = %(LIBS)s %(OTHERLIBS)s
|
|
PYVERSION = %(PYVERSION)s
|
|
PYPREFIX = %(PYPREFIX)s
|
|
EXECPREFIX = %(EXECPREFIX)s
|
|
PYINCLUDE = $(PYPREFIX)/include/python$(PYVERSION)
|
|
EXECINCLUDE = $(EXECPREFIX)/include/python$(PYVERSION)
|
|
PYLIB = %(PYLIB)s
|
|
LIBPL = %(LIBPL)s
|
|
PYTHONLIB = %(PYTHONLIB)s
|
|
FINAL = %(FINAL)s
|
|
WXP_USE_THREAD = %(WXP_USE_THREAD)s
|
|
GENCODEDIR = %(GENCODEDIR)s
|
|
WXPSRCDIR = %(WXPSRCDIR)s
|
|
HELPERLIB = %(HELPERLIB)s
|
|
HELPERLIBDIR = %(HELPERLIBDIR)s
|
|
|
|
TARGETDIR = %(TARGETDIR)s
|
|
|
|
|
|
CCC = %(CCC)s
|
|
CC = %(CC)s
|
|
OPT = %(OPT)s
|
|
SO = %(SO)s
|
|
LDSHARED = %(LDSHARED)s
|
|
CCSHARED = %(CCSHARED)s
|
|
|
|
|
|
OBJECTS = %(OBJECTS)s
|
|
PYMODULES = %(PYMODULES)s
|
|
TARGET = %(TARGET)s
|
|
|
|
|
|
ifeq ($(WXP_USE_THREAD), 1)
|
|
THREAD=-DWXP_USE_THREAD
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
%(DEFAULTRULE)s %(OTHERTARGETS)s
|
|
|
|
install: $(TARGETDIR) $(TARGETDIR)/$(TARGET) pycfiles %(OTHERINSTALLTARGETS)s
|
|
|
|
clean:
|
|
-rm -f *.o *$(SO) *~
|
|
-rm -f $(TARGET)
|
|
|
|
uninstall: %(OTHERUNINSTALLTARGETS)s
|
|
-rm -f $(TARGETDIR)/$(TARGET)
|
|
%(PYCLEANUP)s
|
|
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
%%.o : %%.cpp
|
|
$(CCC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
|
|
|
|
%%.o : $(GENCODEDIR)/%%.cpp
|
|
$(CCC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
|
|
|
|
%%.o : %%.c
|
|
$(CC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
|
|
|
|
%%.o : $(GENCODEDIR)/%%.c
|
|
$(CC) $(CCSHARED) $(CFLAGS) $(OTHERCFLAGS) -c $<
|
|
|
|
$(GENCODEDIR)/%%.cpp : %%.i
|
|
swig $(SWIGFLAGS) -c -o $@ $<
|
|
|
|
$(GENCODEDIR)/%%.py : %%.i
|
|
swig $(SWIGFLAGS) -c -o $(GENCODEDIR)/tmp_wrap.cpp $<
|
|
rm $(GENCODEDIR)/tmp_wrap.cpp
|
|
|
|
$(TARGETDIR)/%% : %%
|
|
cp -f $< $@
|
|
|
|
$(TARGETDIR)/%% : $(GENCODEDIR)/%%
|
|
cp -f $< $@
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
%(DEPENDS)s
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
$(TARGET) : $(OBJECTS)
|
|
$(LDSHARED) $(OBJECTS) $(LFLAGS) $(LIBS) $(OTHERLIBS) -o $(TARGET)
|
|
|
|
|
|
|
|
pycfiles : $(PYMODULES)
|
|
$(EXECPREFIX)/bin/python $(PYLIB)/compileall.py -l $(TARGETDIR)
|
|
$(EXECPREFIX)/bin/python -O $(PYLIB)/compileall.py -l $(TARGETDIR)
|
|
|
|
|
|
$(TARGETDIR) :
|
|
mkdir $(TARGETDIR)
|
|
|
|
$(GENCODEDIR):
|
|
mkdir $(GENCODEDIR)
|
|
|
|
#----------------------------------------------------------------------
|
|
|
|
|
|
%(OTHERRULES)s
|
|
|
|
|
|
|
|
'''
|
|
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
if __name__ == '__main__':
|
|
main(sys.argv)
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|