diff --git a/Buildhelper.py b/Buildhelper.py index de44dce4b..31e04452a 100644 --- a/Buildhelper.py +++ b/Buildhelper.py @@ -2,6 +2,7 @@ ## ## Buildhelper.py - helpers, custom builders, for SConstruct ## +from fnmatch import fnmatch # Copyright (C) CinelerraCV # 2007, Hermann Vosseler @@ -21,9 +22,50 @@ # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ##################################################################### +import os +import sys +import fnmatch # # Common Helper Functions # def isCleanupOperation(env): return env.GetOption('clean') + +def isHelpRequest(): + ''' this is a hack: SCons does all configure tests even if only + the helpmessage is requested. SCons doesn't export the + help option for retrieval by env.GetOption(), + so we scan the commandline directly. + ''' + return '-h' in sys.argv or '--help' in sys.argv + + + +def srcSubtree(env,tree,isShared=False, **args): + ''' convienience wrapper: scans the given subtree, which is + to be located within $SRCDIR, find all source files and + declare them as Static or SharedObjects for compilation + ''' + root = env.subst('$SRCDIR/%s' % tree) # expand $SRCDIR + if isShared: + builder = lambda f: env.SharedObject(f, **args) + else: + builder = lambda f: env.Object(f, **args) + + return [builder(f) for f in scanSrcSubtree(root)] + + + +SRCPATTERNS = ['*.c','*.Cpp','*.cc'] + +def scanSrcSubtree(root): + ''' scan the given subtree for source filesnames + (python generator function) + ''' + for (dir,_,files) in os.walk(root): + if dir.startswith('./'): + dir = dir[2:] + for p in SRCPATTERNS: + for f in fnmatch.filter(files, p): + yield os.path.join(dir,f) diff --git a/SConstruct b/SConstruct index 58b8a30d4..fc05fe595 100644 --- a/SConstruct +++ b/SConstruct @@ -21,16 +21,188 @@ # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ##################################################################### +import os +import re + from Buildhelper import * +#-----------------------------------Configuration +OPTIONSCACHEFILE = 'optcache' +CUSTOPTIONSFILE = 'custom-options' +SRCDIR = 'src' +BINDIR = 'src/bin' +VERSION = '3.alpha.1' +#-----------------------------------Configuration + + + + + +##################################################################### + +def setupBasicEnvironment(): + ''' define cmdline options, build type decisions + ''' + opts = defineCmdlineOptions() + + env = Environment( options=opts + , CPPDEFINES={'DEBUG': '${DEBUG}' + ,'USE_OPENGL': '${OPENGL}' + } + ) + env.Replace( VERSION=VERSION + , SRCDIR=SRCDIR + , BINDIR=BINDIR + , CPPPATH=SRCDIR # used to find includes + ) + prepareOptionsHelp(opts,env) + opts.Save(OPTIONSCACHEFILE, env) + return env + + +def defineCmdlineOptions(): + ''' current options will be persisted in a options cache file. + you may define custom options in a separate file. + Commandline will override both. + ''' + opts = Options([OPTIONSCACHEFILE, CUSTOPTIONSFILE]) + opts.AddOptions( + ('ARCHFLAGS', 'Set architecture-specific compilation flags (passed literally to gcc)','') + ,BoolOption('DEBUG', 'Build with debugging information and no optimizations', False) + ,BoolOption('OPTIMIZE', 'Build with strong optimization (-O3)', False) + ,BoolOption('OPENGL', 'Include support for OpenGL preview rendering', False) +# ,EnumOption('DIST_TARGET', 'Build target architecture', 'auto', +# allowed_values=('auto', 'i386', 'i686', 'x86_64' ), ignorecase=2) + ,PathOption('DESTDIR', 'Installation dir prefix', '/usr/local') + ,PackageOption('TARSRC', 'Create source tarball prior to compiling', '.') + ,PackageOption('TARDOC', 'Create tarball with dev documentaion, wiki and uml model', '.') + ) + + return opts + + +def prepareOptionsHelp(opts,env): + prelude = ''' +USAGE: scons [-c] [OPTS] [TARGETS] + Build and optionally install Cinelerra. + Without specifying any target, just the (re)build target will run. + Add -c to the commandline to clean up anything a given target would produce + +Configuration Options: +''' + Help(prelude + opts.GenerateHelpText(env)) + + + +def configurePlatform(env): + ''' locate required libs. + setup platform specific options. + Abort build in case of failure. + ''' + conf = Configure(env) + # run all configuration checks in the current env + + # Checks for prerequisites ------------ + if not conf.CheckLibWithHeader('m', 'math.h','C'): + print 'Did not find math.h / libm, exiting.' + Exit(1) + + if not conf.CheckCXXHeader('boost/config.hpp'): + print 'We need the C++ boost-lib.' + Exit(1) + + if not conf.CheckCXXHeader('boost/shared_ptr.hpp'): + print 'We need boost::shared_ptr (shared_ptr.hpp).' + Exit(1) + + # create new env containing the finished configuration + return conf.Finish() + + + +def definePackagingTargets(env, artifacts): + ''' build operations and targets to be done /before/ compiling. + things like creating a source tarball or preparing a version header. + ''' + env.SetDefault(TARFLAGS = '-c -z', TARSUFFIX = '') + if env['TARSRC']: + # define the Tar as a target and make it default, + # i.e. buid it if scons is called without targets + t=env.Tar(getTarName(env['TARSRC']),SRCDIR) + env.Default(t) + if env['TARDOC']: + t=env.Tar(getTarName(env['TARDOC']), 'admin doc wiki uml tests') + env.Default(t) + +def getTarName(spec): + (head,tail) = os.path.split( os.path.abspath(spec)) + if not os.path.isdir(head): + print 'Target dir "%s" for Tar doesn\'t exist.' % head + Exit(1) + mat = re.match(r'([\w\.\-])\.((tar)|(tar\.gz)|(tgz))', tail) + if mat: + name = mat.group(1) + ext = '.'+mat.group(2) + else: + ext = '.tar.gz' + if os.path.isdir(tail): + name = 'cinelerra$VERSION' + else: + name = tail + return os.path.join(head,name+ext) + + + +def defineBuildTargets(env, artifacts): + ''' define the source file/dirs comprising each artifact to be built. + setup sub-environments with special build options if necessary + ''' + cinobj = ( srcSubtree(env,'backend') + + srcSubtree(env,'proc') + + env.Object('$SRCDIR/main.cpp') + ) + plugobj = srcSubtree(env,'plugin', isShared=True) + + artifacts['cinelerra'] = env.Program('$BINDIR/cinelerra', cinobj) + artifacts['plugins'] = env.SharedLibrary('$BINDIR/cinelerra-plugin', plugobj) + + # call subdir SConscript(s) + SConscript(dirs=[SRCDIR+'/tool'], exports='env artifacts') + + + +def defineInstallTargets(env, artifacts): + ''' define install locations and cleanup after the build. + define alias targets to trigger the installing. + ''' + env.Install(dir = '$DESTDIR/bin', source=artifacts['cinelerra']) + env.Install(dir = '$DESTDIR/lib', source=artifacts['plugins']) + env.Install(dir = '$DESTDIR/bin', source=artifacts['tools']) + + ib = env.Alias('install-bin', '$DESTDIR/bin') + il = env.Alias('install-lib', '$DESTDIR/lib') + env.Alias('install', [ib, il]) + + env.Alias('build', '$DESTDIR') + env.Default('build') + # additional files to be cleaned when cleaning 'build' + env.Clean ('build', [ 'scache.conf', '.sconf_temp', '.sconsign.dblite', 'config.log']) + +##################################################################### + + + + + +### === MAIN === #################################################### # NOTE: the following code /defines/ what and how to build # it doesn't "do" the build. SCons will do the "doing" env = setupBasicEnvironment() -if not isCleanupOperation(env): - configurePlatform(env) +if not (isCleanupOperation(env) or isHelpRequest()): + env = configurePlatform(env) artifacts = {} # the various things we build. @@ -46,36 +218,3 @@ definePackagingTargets(env, artifacts) defineBuildTargets(env, artifacts) defineInstallTargets(env, artifacts) - -##################################################################### - -def setupBasicEnvironment(): - ''' define cmdline options, decide build type - ''' - - -def configurePlatform(env): - ''' locate required libs. - setup platform specific options. - Abort build in case of failure. - ''' - - -def definePackagingTargets(env, artifacts): - ''' build operations and targets to be done /before/ compiling. - things like creating a source tarball or preparing a version header. - ''' - - -def defineBuildTargets(env, artifacts): - ''' define the source file/dirs comprising each artifact to be built. - setup sub-environments with special build options if necessary - ''' - - -def defineInstallTargets(env, artifacts): - ''' define install locations and cleanup after the build. - define alias targets to trigger the installing. - ''' - - diff --git a/src/tool/DIR_INFO b/src/tool/DIR_INFO new file mode 100644 index 000000000..76e84db53 --- /dev/null +++ b/src/tool/DIR_INFO @@ -0,0 +1 @@ +source code of supplementary tools to be built alongside with Cinelerra diff --git a/src/tool/SConscript b/src/tool/SConscript new file mode 100644 index 000000000..e4c744190 --- /dev/null +++ b/src/tool/SConscript @@ -0,0 +1,10 @@ +# -*- python -*- +## +## SConscript - SCons buildscript for tool subdirectory (called by SConstruct) +## + +Import('env','artifacts') + +# build the ubiquitous Hello World application (note: C source) +artifacts['tools'] = env.Program('$BINDIR/hello-world','hello.c') + diff --git a/src/tool/hello.c b/src/tool/hello.c new file mode 100644 index 000000000..62a033f4e --- /dev/null +++ b/src/tool/hello.c @@ -0,0 +1,12 @@ +/* + * hello.c - demonstrates how to build a standalone tool (C source) + * integrated into the SCons based build system of Cinelerra + */ + +#include + +int main(int argc, char* argv[]) + { + printf("hello cinelerra world"); + return 0; + }