wxWidgets/utils/wxPython/distrib/build.py

#!/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.14'

#----------------------------------------------------------------------------

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:
                self.CCC = os.popen('wx-config --cxx', 'r').read()[:-1]
                if not self.CCC:
                    print "Warning: C++ compiler not specified (CCC). Assuming c++"
                    self.CCC = 'c++'
            if not self.CC:
                self.CCC = os.popen('wx-config --cc', 'r').read()[:-1]
                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) /export:init$(MODULE) /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)

#----------------------------------------------------------------------------