Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
694759cfeb701f8b96d720e72f760cc21e2e6b00
wxWidgets/utils/wxPython/distrib/build.py
Robin Dunn 65dd82cbce wxPython stuff: 
1. Added test for HTML printing
  2. Update wxFontEnumerator
  3. wxPyEvent and wxPyCommandEvent derived classes now return the
     actual Python object in the event handler.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4416 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1999-11-07 07:49:09 +00:00

790 lines
24 KiB
Python
Executable File
Raw Blame History

#!/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.11'
#----------------------------------------------------------------------------
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)
self.CRTFLAG = ''
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
CRTFLAG=%(CRTFLAG)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 $<
ifndef NOSWIG
$(GENCODEDIR)/%%.cpp : %%.i
swig $(SWIGFLAGS) -c -o $@ $<
$(GENCODEDIR)/%%.py : %%.i
swig $(SWIGFLAGS) -c -o $(GENCODEDIR)/tmp_wrap.cpp $<
rm $(GENCODEDIR)/tmp_wrap.cpp
endif
$(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 -p $(TARGETDIR)
$(GENCODEDIR):
mkdir $(GENCODEDIR)
#----------------------------------------------------------------------
%(OTHERRULES)s
'''
#----------------------------------------------------------------------------
if __name__ == '__main__':
err = main(sys.argv)
sys.exit(err)
#----------------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink