finished basic implementation of SCons build system

Buildhelper.py

@@ -2,6 +2,7 @@
 ##
 ## Buildhelper.py  -  helpers, custom builders, for SConstruct
 ##
+from fnmatch import fnmatch
 
 #  Copyright (C)         CinelerraCV
 #    2007,               Hermann Vosseler <Ichthyostega@web.de>
@@ -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)

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.
-    '''
-
-

src/tool/DIR_INFO

@@ -0,0 +1 @@
+source code of supplementary tools to be built alongside with Cinelerra

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')
+

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 <stdio.h>
+
+int main(int argc, char* argv[])
+  {
+    printf("hello cinelerra world");
+    return 0;
+  }