root/trunk/SConstruct

"""
SConstruct for iplt

This file is part of the image processing library & toolbox
for electron microscopy, licensed under the GPL. Please see
the accompanying LICENSE file for more information. The iplt
homepage is http://www.iplt.org

Author: Ansgar Philippsen

"""

EnsureSConsVersion(0,95)

import SCons, re
import sys, os, os.path, string, copy, shutil
from types import *

sys.path.append("utils")

# defines routines to discriminate the platform
from Platform import *
platform = GetPlatform()

if platform.GetName()=="win32":
        sys.argv=sys.argv[1:] # remove first '-c' under win32

skip_config=0

if 'doc' in COMMAND_LINE_TARGETS and len(COMMAND_LINE_TARGETS)==1:
    skip_config=1

if "-c" in sys.argv:
    skip_config=1

# define an extended scons environment
from Environ import *
from DoConfig import *

# get custom options
version_string=SCons.__version__
version = string.split(string.split(version_string, ' ')[0], '.')
v_major = int(version[0])
v_minor = int(re.match('\d+', version[1]).group())
if len(version) >= 3:
  v_revision = int(re.match('\d+', version[2]).group())
else:
  v_revision = 0
if v_major == 0 and v_minor < 98:
  opts = Options("settings.py")
else:
  opts = Variables("settings.py")
opts.Add("EXTRA_INCLUDE_PATH","extra include paths","")
opts.Add("EXTRA_LIBRARY_PATH","extra library search paths","")
opts.Add("EXTRA_FRAMEWORK_PATH","extra framework search paths. Affects MacOS X only","")
opts.Add("EXTRA_CC_FLAGS","extra flags for c++ compiler","")
opts.Add("EXTRA_LINK_FLAGS","extra flags for linker","")
opts.Add("EXTRA_LIBS","extra libraries to include at link time","")
opts.Add("BOOST_LIBS_SUFFIX","postfix for boost libraries","")
opts.Add("PYTHON_VERSION","python version (maj.min), override automatic python detection","")
opts.Add("INSTALL_PATH","location for installation","")
opts.Add("CC","explicit C compiler")
opts.Add("CXX","explicit C++ compiler")
opts.Add("LINK","explicit linker to use")


# setup basic environment
env = Environment(options=opts, ENV = os.environ)
env.platform_name=platform.GetName()
# the following hack is necessary to avoid weird unicode issues with python 2.6 on some platforms
#env.Append(CCFLAGS='$TRANSLATION_UNITS')
env['CCFLAGS'].append('$TRANSLATION_UNITS')
env['TRANSLATION_UNITS']=translation_units(env)

platform.SetLibDir(env)
#add pyc builder
def pyc_action(target,source,env):
    import compiler
    for s in source:
        ret=compiler.compileFile(str(s))
        if ret:
            return -1

    return 0
def pyc_string(target,source,env):
    for s in source:
        return "byte compiling %s"%(str(s))

pyc_builder = Builder(action=Action(pyc_action,pyc_string),
                      suffix='.pyc',src_suffix='.py',
                      single_source=True)
env.Append(BUILDERS = {'PyC':pyc_builder})


if os.getenv('IPLT_STAGE'):
  env.SetStageDir(os.getenv('IPLT_STAGE'))
else:
  env.SetStageDir("#/stage")

if "-c" in sys.argv:
    print "removing stage dir '"+str(Dir(env.GetStageDir()))+"' ..."
    shutil.rmtree(str(Dir(env.GetStageDir())),True)
    print "done"

platform.SetCompilerFlags(env)
platform_name = platform.GetName()

boost_suffix = env["BOOST_LIBS_SUFFIX"]

env.Append(CPPPATH = [env._stagedir + "/include","#extra/include"] + string.split(env["EXTRA_INCLUDE_PATH"]) )

env.Append(LIBPATH = string.split(env["EXTRA_LIBRARY_PATH"]) )
env.Append(CCFLAGS = string.split(env["EXTRA_CC_FLAGS"]))
env.Append(LINKFLAGS = string.split(env["EXTRA_LINK_FLAGS"]))
env.Append(FRAMEWORKPATH=string.split(env["EXTRA_FRAMEWORK_PATH"]))
abs_lib_dir = os.getcwd() + "/" + str(env.Dir(env._stagedir)) + "/"+env.GetLibDir()

extra_libs = string.split(env["EXTRA_LIBS"])

env.Append(LIBS = extra_libs)

do_config=0 #TODO override with command line option

centries=[]

if skip_config:
    print "Skipping Configuration"
else:
    if not do_config:
        if os.path.isfile("config.save"):
            print "Using configuration settings in config.save"
            cfile=file("config.save","r")
            centries=cfile.readlines()
            cfile.close()
        else:
            print "No pre-configured state found, running configuration"
            do_config=1
    else:
        print "Running configuration"

    env=Configure_Main(env,boost_suffix,do_config,centries)
    tmpenv=Configure_tmp(env.Clone(),boost_suffix,do_config,centries)


# the Pymod environment adds the necessary flags and builder
# it is derived from the basic environment
pymod_env = env.Clone()
platform.AddPythonInclude(pymod_env, env["PYTHON_VERSION"])
#platform.AddPythonLib(pymod_env, env["PYTHON_VERSION"]) # not required !!
platform.SetPymodBuilder(pymod_env)
pymod_env.Prepend(LIBPATH = env._stagedir+"/"+pymod_env.GetLibDir())
pymod_env.Append(LIBS = ["iplt","iplt_geom"])
if not skip_config:
    pymod_env = Configure_Pymod(pymod_env,boost_suffix,do_config,centries)

# algorithm environment, based on basic env
alg_env = env.Clone()
alg_env.Prepend(LIBPATH = env._stagedir+"/"+pymod_env.GetLibDir())
alg_env.Append(LIBS = ["iplt","iplt_geom","iplt_info"]+extra_libs) # iplt_geom added for OSX

# plugin environment, based on basic env
plugin_env = env.Clone()
platform.SetPluginInfo(plugin_env)
plugin_env.Prepend(LIBPATH = env._stagedir+"/"+pymod_env.GetLibDir())
plugin_env.Append(LIBS = extra_libs)

# the wxwindows environment, based on basic env
wxwin_env = env.Clone()
# static library hack
wxwin_env._dict["STATICLIBS"]= []
platform.SetWXInfo(wxwin_env)
wxwin_env.Prepend(LIBPATH = env._stagedir+"/"+pymod_env.GetLibDir())
wxwin_env.Append(LIBS = extra_libs)
platform.AddPythonInclude(wxwin_env, env["PYTHON_VERSION"])
platform.AddPythonLib(wxwin_env, env["PYTHON_VERSION"]) # required!

pyapp_env = env.Clone()
platform.AddPythonInclude(pyapp_env, env["PYTHON_VERSION"])
platform.AddPythonLib(pyapp_env, env["PYTHON_VERSION"])

if not 'nogui' in COMMAND_LINE_TARGETS and not skip_config:
    wxwin_env = Configure_wx(wxwin_env,do_config,centries)

if do_config and not skip_config:
    print "Writing configuration to config.save"
    cfile=file("config.save","w")
    cfile.writelines(centries)
    cfile.close()


# app env
app_env = env.Clone()
app_env.Append(LIBS = ["iplt"])
app_env.Prepend(LIBPATH = env._stagedir+"/"+pymod_env.GetLibDir())
app_env.Append(LIBS = extra_libs)

# unit tests env
test_env = env.Clone()
#test_env.Append(LIBS = 'boost_unit_test_framework' + env["BOOST_LIBS_SUFFIX"])
test_env.Append(LIBS = 'iplt')
test_env.Prepend(LIBPATH = env._stagedir+"/"+pymod_env.GetLibDir())
test_env.Append(LIBS = extra_libs)
# The following  line was added to make iplt compatible with boost 1.34. We must now link
# statically to boost.test and dynamically to everything else. Not sure if this
# is portable to non-gcc compilers, probably not.
if platform_name=="win32":
    test_env.Append(LINKCOM=" E:/sft/lib/boost_unit_test_framework-vc80-mt.lib")
else:
    test_env.Append(LINKCOM = ' -Wl,-Bstatic -lboost_unit_test_framework' + env["BOOST_LIBS_SUFFIX"]  + ' -Wl,-Bdynamic')
# doc environment
from doxy import DoxyEnvironment
doc_env=DoxyEnvironment()

Export(["env","pymod_env","alg_env","plugin_env","wxwin_env","app_env","test_env","doc_env","pyapp_env","platform_name"])

# build targets
Alias("libs")
Alias("gui")
Alias("python_modules")
Alias("unit_tests")
Alias("default",["libs","gui","python_modules"])
Alias("all",["default","unit_tests"])

#nogui = ['src/base','src/misc','src/io','src/alg','src/info']
#default = nogui + ['src/gui']

Default("default")

SConscript(dirs="src")

def install_all(target=None, source=None, env=None):
    p = env["INSTALL_PATH"];
    if(p == ""):
        print "no INSTALL_PATH specified in settings file, install aborted"
        return -1
    env.InstallDir(Dir("#stage"),Dir(p),"bin")
    env.InstallDir(Dir("#stage"),Dir(p),pymod_env.GetLibDir())
    env.InstallDir(Dir("#stage"),Dir(p),"include")


env.Command("install","",Action(install_all))
env.Depends("install","default")
env.AlwaysBuild("install")

#env.Alias("all", default + ['install'])
#env.Alias("nogui", nogui)

env.Alias("configure")

if 'doc' in COMMAND_LINE_TARGETS:
    doc_env.BuildAll(env._stagedir +'/share/doc/iplt')