source: trunk/ithildin/SConstruct @ 797

# #############################################################################
# SConstruct: SCons build instructions
#
# Copyright 2006 the Ithildin Project.
# See the COPYING file for more information on licensing and use.
#
# $Id$
#
# #############################################################################

###############################################################################
# Initial setup (Python path tweaks etc)

package_name = "ithildin"
package_version = "1.2.0"

EnsurePythonVersion(2,2)
EnsureSConsVersion(0,96,92)

import glob, os, sys
# let's just stick the realpath() for ./build in there at the front.  THis
# allows us to use our custom test code in the 'tests' module there.
sys.path.insert(0, os.path.realpath('./build'))
import tests

###############################################################################
# Global environment setup.  Import the user's $PATH for our own sanity.
env = Environment(ENV = {
    'PATH': os.environ['PATH'],
    },
    CPPPATH = ['#/include']
)

# Perform some magic to get the repository version.  If we have svn and we
# can use xml.dom.minidom let's go for it
try:
    subversion = WhereIs('svn')
    import xml.dom.minidom
    if subversion:
        dom = xml.dom.minidom.parseString(
            os.popen('%s info --xml .' % subversion).read())
        e = dom.getElementsByTagName('entry')[0]
        package_repository_version = int(e.getAttribute('revision'))
        dom.unlink()
except:
    # no luck eh, let's cheat
    svnrev = "$Rev$"
    package_repository_version = int(svnrev.split()[1])

# Find our availabe modules
available_modules = []
for e in os.listdir('modules'):
    if os.path.exists('modules/%s/SConscript' % e):
        available_modules.append(e)
available_modules.sort()

###############################################################################
# Options

# Collect the list of modules we have shipped with

if not os.path.exists('build/options'):
    env.Help("""
You may save your build options in the file build/options with the format:
optionname = "optionvalue"
A sample options file is provided in build/options.default.
""")

opts = Options('build/options', ARGUMENTS)
opts.AddOptions(
    BoolOption('debug', 'Enable creation of debugging symbols', 0),
    ('fdsetsize', 'Override value of FD_SETSIZE', 0),
    BoolOption('ipv6', 'Enable IPv6 support', 1),
    ListOption('modules', 'Modules to build', 'all', available_modules),
    PackageOption('openssl', 'Enable OpenSSL support', 'yes'),
    ListOption('poller', 'Socket polling method', 'auto',
        ['kqueue', 'poll', 'select', 'auto']),
    BoolOption('warnings', 'Compile with very aggressive warning settings', 0),
# Other path options are handled below 
    PathOption('prefix', 'Installation prefix', '/usr/local',
        tests.PathIsDirCreateAccess),
)
opts.Update(env)

# Now take a look in prefix for the stuff we care about: bin, etc, lib,
# include, share.  If these already exist we make our defaults
# $prefix/etc/ithildin etc.  Otherwise we make them $prefix/etc (assuming
# this is a lone installation location).  This is an automated version of
# the old  --disable-dir-suffix autoconf macro from 1.1 and lower.
#
# XXX: this is all dumb in Windows where installations will be totally
# different.

# Okay, let's make some dumb guesses:  If the name already contains
# 'package' in it let's go ahead and not add that again.  If the name is
# standard (/usr, /usr/local, /opt) let's add it there.  Other than that we
# aren't too smart. :)
if env['prefix'] == '/usr' or env['prefix'] == '/opt':
    # /usr and /opt need special handling to stuff things in /etc
    sysconfdir = '/etc'
else:
    sysconfdir = env['prefix'] + '/etc'

dir_suffix = ''
if not package_name in env['prefix']:
    dir_suffix = '/' + package_name
# let's add one more, if it's in $HOME/<something> let's guess that they
# don't want that nasty dir_suffix.  This could be so wrong as to be absurd,
# but I believe it is what most will want.
if (os.environ.has_key('HOME') and os.environ['HOME'] in env['prefix']):
    dir_suffix = ''

opts.AddOptions(
    PathOption('bindir', "Binary installation directory",
        env['prefix'] + '/bin', tests.PathIsDirCreateAccess),
    PathOption('sysconfdir', "Configuration file installation directory",
        sysconfdir + dir_suffix, tests.PathIsDirCreateAccess),
    PathOption('libdir', "Library installation directory",
        env['prefix'] + '/lib' + dir_suffix, tests.PathIsDirCreateAccess),
    PathOption('includedir', 'C header installation directory',
        env['prefix'] + '/include', tests.PathIsDirCreateAccess),
    PathOption('datadir', "Miscellaneous file installation directory",
        env['prefix'] + '/share' + dir_suffix, tests.PathIsDirCreateAccess),
)
opts.Update(env)

env.Help(opts.GenerateHelpText(env))

###############################################################################
# Feature tests

conf = env.Configure(config_h = 'include/ithildin/config.h',
    custom_tests = tests.tests)

conf.CheckCCompiler()
conf.CheckCVersion()

# header tests:
# We have headers we want, headers we need, and we save all this to a final
# variable listing all the headers we have.
need_headers = Split('''
assert.h errno.h limits.h math.h stdbool.h string.h
''')
want_headers = Split('''
dl.h dlfcn.h fcntl.h features.h grp.h netdb.h pwd.h strings.h time.h unistd.h 
arpa/inet.h
machine/endian.h
netinet/in.h
sys/mman.h sys/resource.h sys/socket.h sys/stat.h sys/time.h

windows.h winsock.h
''')

have_headers = list()
for h in want_headers:
    if conf.CheckHeader(h): have_headers.append(h)
for h in need_headers:
    if conf.CheckHeader(h): have_headers.append(h)
    else:
        print 'Header %s is required for compilation' % h
        env.Exit(1)

# library tests:
# Somewhat different, we use the want/need lists but they are a list of
# tuples (library name and function to check for).  The have list remains a
# list of libs we have

want_libs = [
('dl', 'dlopen'),
('nsl', 'gethostbyname'),
('socket', 'socket'),
]
need_libs = list()
have_libs = list()

for l in want_libs:
    if conf.CheckLib(library = l[0], symbol = l[1]): have_libs.append(l[0])
for l in need_libs:
    if conf.CheckLib(library = l[0], symbol = l[1]): have_libs.append(l[0])
    else:
        print 'Library %s is required for compilation' % l[0]
        env.Exit(1)

# function tests:
# Here again we have functions we need, functioncs we want, and a final
# listing of functions we have
want_funcs = Split('''
getaddrinfo kqueue poll select
fmtcheck strlcat strlcpy strsep
getegid getgid getgrnam setegid setgid setgroups
geteuid getuid getpwnam seteuid setuid
readlink getenv recv send setsockopt
getrlimit setrlimit
''')
# XXX: fill in need_funcs with a reasonable subset of what we need, stuff
# that will prove various libraries exist.  Blech!
need_funcs = list()

have_funcs = list()

for f in want_funcs:
    if conf.CheckFunc(f): have_funcs.append(f)
for f in need_funcs:
    if conf.CheckFunc(f): have_funcs.append(f)
    else:
        print 'Function %s is required for compilation' % f
        env.Exit(1)

# OpenSSL test:
# We need libs and headers above first, in some cases, to test this.
if env['openssl']:
    # if the configured option is not an integer it must be their desired
    # path(s)
    if env['openssl'].__class__ is not int:
        res = conf.CheckOpenSSL(Split(env['openssl']))
    else:
        res = conf.CheckOpenSSL()

    if not res:
        print 'Could not find OpenSSL.  If you wish to build without support'
        print 'for SSL please specify openssl=no to the build command'
        Exit(1)

    env.Append(CPPDEFINES = ['HAVE_OPENSSL'])

# IPv6 test:
# We just look to see if we have getaddrinfo and if they want IPv6 support
if conf.CheckIPv6(have_funcs):
    env.Append(CPPDEFINES = ['INET6'])

# FD_SETSIZE test:
# Just check the passed value and decide whether or not to use this
if env['fdsetsize']:
    env.Append(CPPDEFINES = ['FD_SETSIZE=%s'] % env['fdsetsize'])

# Poller selection:
# If they ask for auto go in the preference order of: kqueue > poll > select
# except when Linux is provided, in which case we always use select() (weird
# breakage with poll() on Linux and it has no kqueue).  If they ask for
# something explicit we'll always use that.
kqueue_supported_on = ['DragonFlyBSD', 'FreeBSD', 'NetBSD', 'OpenBSD']
host_os = os.uname()[0]
if str(env['poller']) == 'auto':
    if host_os == 'Linux':
        env['poller'] = 'select'
    elif 'kqueue' in have_funcs and host_os in kqueue_supported_on:
        env['poller'] = 'kqueue'
    elif 'poll' in have_funcs:
        env['poller'] = 'poll'
    elif 'select' in have_funcs:
        env['poller'] = 'select'
    else:
        print 'Unable to find suitable polling function'
        Exit(1)

# now take the poller value, set for correctness, and double check it
if not str(env['poller']) in have_funcs:
    print 'We do not have the %s poller' % env['poller']
    Exit(1)

env.Append(CPPDEFINES = ['POLLER_%s' % str(env['poller']).upper()])

# And let's set compiler options!
if env['CC'] == 'gcc':
    if env['debug']:
        env.AppendUnique(CCFLAGS = ['-O', '-g3'])
    if env['warnings']:
        env.AppendUnique(CCFLAGS = Split('''
            -Wall -Wshadow -Wmissing-declarations -Wpointer-arith
            -Wcast-align -Wstrict-prototypes -Wmissing-prototypes
            -Wmissing-declarations -Wredundant-decls -Winline
            -Wbad-function-cast
            '''))

conf.Finish()

# leave this here for debugging (just comment it out...)
#print env.Dictionary()

###############################################################################
# Build options and subsidiary code

# Set our final environment parameters.
env.Append(LIBPATH = '#/lib')
env.AppendUnique(RPATH = [env['libdir'], env['libdir'] + '/modules'])

# Update target for subversion users.
if subversion:
    env.AlwaysBuild(env.Alias('update', '#/.svn', '%s update' % subversion))
# Installation targets for documentation, config and include files
tests.AddConfInstall(env, env['sysconfdir'], ['etc/ithildin.conf'])
env.Install(env['datadir'], ['COPYING', 'DEVELOPERS', 'README'])
env.Install(env['datadir'] + '/doc', glob.glob('doc/*.txt'))
env.Install(env['includedir'] + '/ithildin',
    glob.glob('include/ithildin/*.h'))

# dummy install target with our various prefixes.
env.Alias('install', [env['bindir'], env['sysconfdir'],
        env['libdir'], env['includedir'], env['datadir']])

# Now export useful variables
env.Export(['env', 'package_name', 'package_version',
    'package_repository_version', 'tests'])

# and call our sub-scripts.
env.SConscript('lib/SConscript')
env.SConscript('source/SConscript')

# Add the requested modules too!
if str(env['modules']) == 'all':
    modules = str.join(',', available_modules)
elif str(env['modules']) == 'none':
    modules = ''
else:
    modules = str(env['modules'])

for m in modules.split(','):
    if not m: continue
    # create a modified env for each module
    modenv = env.Clone()
    env.SConscript('modules/%s/SConscript' % m, exports = ['modenv'])
    del modenv

# vi:set ts=8 sts=4 sw=4 tw=76 et syntax=python: