wscript
author Tom Henderson <tomh@tomh.org>
Fri, 20 Aug 2010 12:17:19 -0700
changeset 6589 9c325569fb01
parent 6362 ca7a4f7e24e7
permissions -rw-r--r--
Help waf to guess release versions of nsc and pybindgen

## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-

# python lib modules
import sys
import shutil
import types
import optparse
import os.path
import re

# WAF modules
import pproc as subprocess
import Options

import Logs
import TaskGen
import Constants

import ccroot
ccroot.USE_TOP_LEVEL = True

import Task
Task.algotype = Constants.JOBCONTROL # so that Task.maxjobs=1 takes effect

import Utils
import Build
import Configure
import Scripting

sys.path.insert(0, os.path.abspath('waf-tools'))
try:
    import cflags # override the build profiles from waf
finally:
    sys.path.pop(0)

cflags.profiles = {
	# profile name: [optimization_level, warnings_level, debug_level]
	'debug':     [0, 2, 3],
	'optimized': [3, 2, 1],
	'release':   [3, 2, 0],
	}
cflags.default_profile = 'debug'

# local modules
import wutils
import regression

Configure.autoconfig = 1

# the following two variables are used by the target "waf dist"
VERSION = file("VERSION", "rt").read().strip()
APPNAME = 'ns'

wutils.VERSION = VERSION
wutils.APPNAME = APPNAME

#
# The last part of the path name to use to find the regression traces.  The
# path will be APPNAME + '-' + VERSION + REGRESSION_SUFFIX, e.g.,
# ns-3-dev-ref-traces
#
REGRESSION_SUFFIX = "-ref-traces"


# these variables are mandatory ('/' are converted automatically)
srcdir = '.'
blddir = 'build'

def load_env():
    bld_cls = getattr(Utils.g_module, 'build_context', Utils.Context)
    bld_ctx = bld_cls()
    bld_ctx.load_dirs(os.path.abspath(os.path.join (srcdir,'..')),
                      os.path.abspath(os.path.join (srcdir,'..', blddir)))
    bld_ctx.load_envs()
    env = bld_ctx.get_env()
    return env

def get_files(base_dir):
    retval = []
    reference=os.path.dirname(base_dir)
    for root, dirs, files in os.walk(base_dir):
        if root.find('.hg') != -1:
            continue
        for file in files:
            if file.find('.hg') != -1:
                continue
            fullname = os.path.join(root,file)
            # we can't use os.path.relpath because it's new in python 2.6
            relname = fullname.replace(reference + '/','')
            retval.append([fullname,relname])
    return retval


def dist_hook():
    import tarfile
    shutil.rmtree("doc/html", True)
    shutil.rmtree("doc/latex", True)
    shutil.rmtree("nsc", True)

    ## build the name of the traces subdirectory.  Will be something like
    ## ns-3-dev-ref-traces
    traces_name = APPNAME + '-' + VERSION + REGRESSION_SUFFIX
    ## Create a tar.bz2 file with the traces
    env = load_env()
    regression_dir = env['REGRESSION_TRACES']
    if not os.path.isdir(regression_dir):
        Logs.warn("Not creating traces archive: the %s directory does not exist" % regression_dir)
    else:
        traceball = traces_name + wutils.TRACEBALL_SUFFIX
        tar = tarfile.open(os.path.join("..", traceball), 'w:bz2')
        files = get_files(regression_dir)
        for fullfilename,relfilename in files:
            tar.add(fullfilename,arcname=relfilename)
        tar.close()

def set_options(opt):
    # options provided by the modules
    opt.tool_options('compiler_cc')
    opt.tool_options('compiler_cxx')
    opt.tool_options('cflags')

    opt.add_option('--cwd',
                   help=('Set the working directory for a program.'),
                   action="store", type="string", default=None,
                   dest='cwd_launch')

    opt.add_option('--enable-gcov',
                   help=('Enable code coverage analysis.'
                         ' WARNING: this option only has effect '
                         'with the configure command.'),
                   action="store_true", default=False,
                   dest='enable_gcov')

    opt.add_option('--no-task-lines',
                   help=("Don't print task lines, i.e. messages saying which tasks are being executed by WAF."
                         "  Coupled with a single -v will cause WAF to output only the executed commands,"
                         " just like 'make' does by default."),
                   action="store_true", default=False,
                   dest='no_task_lines')

    opt.add_option('--lcov-report',
                   help=('Generate a code coverage report '
                         '(use this option at build time, not in configure)'),
                   action="store_true", default=False,
                   dest='lcov_report')

    opt.add_option('--run',
                   help=('Run a locally built program; argument can be a program name,'
                         ' or a command starting with the program name.'),
                   type="string", default='', dest='run')
    opt.add_option('--command-template',
                   help=('Template of the command used to run the program given by --run;'
                         ' It should be a shell command string containing %s inside,'
                         ' which will be replaced by the actual program.'),
                   type="string", default=None, dest='command_template')
    opt.add_option('--pyrun',
                   help=('Run a python program using locally built ns3 python module;'
                         ' argument is the path to the python program, optionally followed'
                         ' by command-line options that are passed to the program.'),
                   type="string", default='', dest='pyrun')
    opt.add_option('--valgrind',
                   help=('Change the default command template to run programs and unit tests with valgrind'),
                   action="store_true", default=False,
                   dest='valgrind')
    opt.add_option('--shell',
                   help=('DEPRECATED (run ./waf shell)'),
                   action="store_true", default=False,
                   dest='shell')
    opt.add_option('--enable-sudo',
                   help=('Use sudo to setup suid bits on ns3 executables.'),
                   dest='enable_sudo', action='store_true',
                   default=False)
    opt.add_option('--enable-examples',
                   help=('Build the ns-3 examples and samples.'),
                   dest='enable_examples', action='store_true',
                   default=True)
    opt.add_option('--disable-examples',
                   help=('Do not build the ns-3 examples and samples.'),
                   dest='enable_examples', action='store_false')
    opt.add_option('--regression',
                   help=("Enable regression testing; only used for the 'check' target"),
                   default=False, dest='regression', action="store_true")
    opt.add_option('--check',
                   help=('DEPRECATED (run ./test.py)'),
                   default=False, dest='check', action="store_true")
    opt.add_option('--regression-generate',
                   help=("Generate new regression test traces."),
                   default=False, dest='regression_generate', action="store_true")
    opt.add_option('--regression-tests',
                   help=('For regression testing, only run/generate the indicated regression tests, '
                         'specified as a comma separated list of test names'),
                   dest='regression_tests', type="string")
    opt.add_option('--with-regression-traces',
                   help=('Path to the regression reference traces directory'),
                   default=None,
                   dest='regression_traces', type="string")
    opt.add_option('--enable-static',
                   help=('Compile NS-3 statically: works only on linux, without python'),
                   dest='enable_static', action='store_true',
                   default=False)
    opt.add_option('--enable-mpi',
                   help=('Compile NS-3 with MPI and distributed simulation support'),
                   dest='enable_mpi', action='store_true',
                   default=False)
    opt.add_option('--doxygen-no-build',
                   help=('Run doxygen to generate html documentation from source comments, '
                         'but do not wait for ns-3 to finish the full build.'),
                   action="store_true", default=False,
                   dest='doxygen_no_build')

    # options provided in subdirectories
    opt.sub_options('src')
    opt.sub_options('bindings/python')
    opt.sub_options('src/internet-stack')


def _check_compilation_flag(conf, flag, mode='cxx'):
    """
    Checks if the C++ compiler accepts a certain compilation flag or flags
    flag: can be a string or a list of strings
    """

    env = conf.env.copy()
    if mode == 'cxx':
        fname = 'test.cc'
        env.append_value('CXXFLAGS', flag)
    else:
        fname = 'test.c'
        env.append_value('CCFLAGS', flag)
    try:
        retval = conf.run_c_code(code='#include <stdio.h>\nint main() { return 0; }\n',
                                 env=env, compile_filename=fname,
                                 compile_mode=mode, type='cprogram', execute=False)
    except Configure.ConfigurationError:
        ok = False
    else:
        ok = (retval == 0)
    conf.check_message_custom(flag, 'support', (ok and 'yes' or 'no'))
    return ok

    
def report_optional_feature(conf, name, caption, was_enabled, reason_not_enabled):
    conf.env.append_value('NS3_OPTIONAL_FEATURES', (name, caption, was_enabled, reason_not_enabled))

def configure(conf):
    # attach some extra methods
    conf.check_compilation_flag = types.MethodType(_check_compilation_flag, conf)
    conf.report_optional_feature = types.MethodType(report_optional_feature, conf)
    conf.env['NS3_OPTIONAL_FEATURES'] = []

    conf.env['NS3_BUILDDIR'] = conf.blddir
    conf.check_tool('compiler_cc')
    conf.check_tool('compiler_cxx')
    conf.check_tool('cflags', ['waf-tools'])
    try:
        conf.check_tool('pkgconfig', ['waf-tools'])
    except Configure.ConfigurationError:
        pass
    conf.check_tool('command', ['waf-tools'])

    # Check for the location of regression reference traces
    if Options.options.regression_traces is not None:
        if os.path.isdir(Options.options.regression_traces):
            conf.check_message("regression traces location", '', True, ("%s (given)" % Options.options.regression_traces))
            conf.env['REGRESSION_TRACES'] = os.path.abspath(Options.options.regression_traces)
    else:
        traces = os.path.join('..', "%s-%s%s" % (APPNAME, VERSION, REGRESSION_SUFFIX))
        if os.path.isdir(traces):
            conf.check_message("regression reference traces", '', True, ("%s (guessed)" % traces))
            conf.env['REGRESSION_TRACES'] = os.path.abspath(traces)
        del traces
    if not conf.env['REGRESSION_TRACES']:
        conf.check_message("regression reference traces", '', False)

    # create the second environment, set the variant and set its name
    variant_env = conf.env.copy()
    variant_name = Options.options.build_profile

    if Options.options.enable_gcov:
        variant_name += '-gcov'
        variant_env.append_value('CCFLAGS', '-fprofile-arcs')
        variant_env.append_value('CCFLAGS', '-ftest-coverage')
        variant_env.append_value('CXXFLAGS', '-fprofile-arcs')
        variant_env.append_value('CXXFLAGS', '-ftest-coverage')
        variant_env.append_value('LINKFLAGS', '-fprofile-arcs')
    
    conf.env['NS3_ACTIVE_VARIANT'] = variant_name
    variant_env['NS3_ACTIVE_VARIANT'] = variant_name
    variant_env.set_variant(variant_name)
    conf.set_env_name(variant_name, variant_env)
    conf.setenv(variant_name)
    env = variant_env

    if Options.options.build_profile == 'debug':
        env.append_value('CXXDEFINES', 'NS3_ASSERT_ENABLE')
        env.append_value('CXXDEFINES', 'NS3_LOG_ENABLE')

    env['PLATFORM'] = sys.platform

    if conf.env['CXX_NAME'] in ['gcc', 'icc']:
        if Options.options.build_profile == 'release': 
            env.append_value('CXXFLAGS', '-fomit-frame-pointer') 
            if conf.check_compilation_flag('-march=native'):
                env.append_value('CXXFLAGS', '-march=native') 

        if sys.platform == 'win32':
            env.append_value("LINKFLAGS", "-Wl,--enable-runtime-pseudo-reloc")
        elif sys.platform == 'cygwin':
            env.append_value("LINKFLAGS", "-Wl,--enable-auto-import")

        cxx, = env['CXX']

        p = subprocess.Popen([cxx, '-print-file-name=libstdc++.so'], stdout=subprocess.PIPE)
        libstdcxx_location = os.path.dirname(p.stdout.read().strip())
        p.wait()
        if libstdcxx_location:
            conf.env.append_value('NS3_MODULE_PATH', libstdcxx_location)

        if Options.platform in ['linux']:
            if conf.check_compilation_flag('-Wl,--soname=foo'):
                env['WL_SONAME_SUPPORTED'] = True

    conf.sub_config('src')
    conf.sub_config('bindings/python')

    if Options.options.enable_modules:
        conf.env['NS3_ENABLED_MODULES'] = ['ns3-'+mod for mod in
                                           Options.options.enable_modules.split(',')]
    # for MPI
    conf.find_program('mpic++', var='MPI')
    if Options.options.enable_mpi and conf.env['MPI']:
        p = subprocess.Popen([conf.env['MPI'], '-showme:compile'], stdout=subprocess.PIPE)
        flags = p.stdout.read().rstrip().split()
        p.wait()
        env.append_value("CXXFLAGS_MPI", flags)

        p = subprocess.Popen([conf.env['MPI'], '-showme:link'], stdout=subprocess.PIPE)
        flags = p.stdout.read().rstrip().split()
        p.wait()
        env.append_value("LINKFLAGS_MPI", flags)

        env.append_value('CXXDEFINES', 'NS3_MPI')
        conf.report_optional_feature("mpi", "MPI Support", True, '')
        conf.env['ENABLE_MPI'] = True
    else:
        if Options.options.enable_mpi:
            conf.report_optional_feature("mpi", "MPI Support", False, 'mpic++ not found')
        else:
            conf.report_optional_feature("mpi", "MPI Support", False, 'option --enable-mpi not selected')

    # for suid bits
    conf.find_program('sudo', var='SUDO')

    why_not_sudo = "because we like it"
    if Options.options.enable_sudo and conf.env['SUDO']:
        env['ENABLE_SUDO'] = True
    else:
        env['ENABLE_SUDO'] = False
        if Options.options.enable_sudo:
            why_not_sudo = "program sudo not found"
        else:
            why_not_sudo = "option --enable-sudo not selected"

    conf.report_optional_feature("ENABLE_SUDO", "Use sudo to set suid bit", env['ENABLE_SUDO'], why_not_sudo)

    if Options.options.enable_examples:
        env['ENABLE_EXAMPLES'] = True
        why_not_examples = "defaults to enabled"
    else:
        env['ENABLE_EXAMPLES'] = False
        why_not_examples = "option --disable-examples selected"

    conf.report_optional_feature("ENABLE_EXAMPLES", "Build examples and samples", env['ENABLE_EXAMPLES'], 
                                 why_not_examples)

    # we cannot pull regression traces without mercurial
    conf.find_program('hg', var='MERCURIAL')

    conf.find_program('valgrind', var='VALGRIND')

    env['ENABLE_STATIC_NS3'] = False
    if Options.options.enable_static:
        if env['PLATFORM'].startswith('linux') and \
                env['CXX_NAME'] in ['gcc', 'icc']:
            if re.match('i[3-6]86', os.uname()[4]):
                conf.report_optional_feature("static", "Static build", True, '')
                env['ENABLE_STATIC_NS3'] = True
            elif os.uname()[4] == 'x86_64':
                if env['ENABLE_PYTHON_BINDINGS'] and \
                        not conf.check_compilation_flag('-mcmodel=large'):
                    conf.report_optional_feature("static", "Static build", False,
                                                 "Can't enable static builds because " + \
                                                     "no -mcmodel=large compiler " \
                                                     "option. Try --disable-python or upgrade your " \
                                                     "compiler to at least gcc 4.3.x.")
                else:
                    conf.report_optional_feature("static", "Static build", True, '')
                    env['ENABLE_STATIC_NS3'] = True                    
        elif env['CXX_NAME'] == 'gcc' and \
                (env['PLATFORM'].startswith('darwin') or \
                     env['PLATFORM'].startswith('cygwin')):
                conf.report_optional_feature("static", "Static build", True, '')
                env['ENABLE_STATIC_NS3'] = True
        else:
            conf.report_optional_feature("static", "Static build", False,
                                         "Unsupported platform")
    else:
        conf.report_optional_feature("static", "Static build", False,
                                     "option --enable-static not selected")
    have_gsl = conf.pkg_check_modules('GSL', 'gsl', mandatory=False)
    conf.env['ENABLE_GSL'] = have_gsl

    conf.report_optional_feature("GSL", "GNU Scientific Library (GSL)",
                                 conf.env['ENABLE_GSL'],
                                 "GSL not found")
    if have_gsl:
        conf.env.append_value('CXXDEFINES', "ENABLE_GSL")
        conf.env.append_value('CCDEFINES', "ENABLE_GSL")

    # for compiling C code, copy over the CXX* flags
    conf.env.append_value('CCFLAGS', conf.env['CXXFLAGS'])
    conf.env.append_value('CCDEFINES', conf.env['CXXDEFINES'])

    def add_gcc_flag(flag):
        if env['COMPILER_CXX'] == 'g++' and 'CXXFLAGS' not in os.environ:
            if conf.check_compilation_flag(flag, mode='cxx'):
                env.append_value('CXXFLAGS', flag)
        if env['COMPILER_CC'] == 'gcc' and 'CCFLAGS' not in os.environ:
            if conf.check_compilation_flag(flag, mode='cc'):
                env.append_value('CCFLAGS', flag)

    add_gcc_flag('-Wno-error=deprecated-declarations')
    add_gcc_flag('-fstrict-aliasing')
    add_gcc_flag('-Wstrict-aliasing')


    # append user defined flags after all our ones
    for (confvar, envvar) in [['CCFLAGS', 'CCFLAGS_EXTRA'],
                              ['CXXFLAGS', 'CXXFLAGS_EXTRA'],
                              ['LINKFLAGS', 'LINKFLAGS_EXTRA'],
                              ['LINKFLAGS', 'LDFLAGS_EXTRA']]:
        if envvar in os.environ:
            conf.env.append_value(confvar, os.environ[envvar])

    # Write a summary of optional features status
    print "---- Summary of optional NS-3 features:"
    for (name, caption, was_enabled, reason_not_enabled) in conf.env['NS3_OPTIONAL_FEATURES']:
        if was_enabled:
            status = 'enabled'
        else:
            status = 'not enabled (%s)' % reason_not_enabled
        print "%-30s: %s" % (caption, status)


class SuidBuildTask(Task.TaskBase):
    """task that makes a binary Suid
    """
    after = 'cxx_link cc_link'
    maxjobs = 1
    def __init__(self, bld, program):
        self.bld = bld
        self.m_display = 'build-suid'
        self.__program = program
        self.__env = bld.env.copy ()
        super(SuidBuildTask, self).__init__(generator=self)
        try:
            program_obj = wutils.find_program(self.__program.target, self.__env)
        except ValueError, ex:
            raise Utils.WafError(str(ex))
        program_node = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj))
        self.filename = program_node.abspath(self.__env)


    def run(self):
        print >> sys.stderr, 'setting suid bit on executable ' + self.filename
        if subprocess.Popen(['sudo', 'chown', 'root', self.filename]).wait():
            return 1
        if subprocess.Popen(['sudo', 'chmod', 'u+s', self.filename]).wait():
            return 1
        return 0

    def runnable_status(self):
        "RUN_ME SKIP_ME or ASK_LATER"
        st = os.stat(self.filename)
        if st.st_uid == 0:
            return Constants.SKIP_ME
        else:
            return Constants.RUN_ME


def create_suid_program(bld, name):
    program = bld.new_task_gen('cxx', 'program')
    program.is_ns3_program = True
    program.module_deps = list()
    program.name = name
    program.target = name

    if bld.env['ENABLE_SUDO']:
        SuidBuildTask(bld, program)

    return program

def create_ns3_program(bld, name, dependencies=('simulator',)):
    program = bld.new_task_gen('cxx', 'program')
    program.is_ns3_program = True
    program.name = name
    program.target = program.name
    program.uselib_local = 'ns3'
    program.ns3_module_dependencies = ['ns3-'+dep for dep in dependencies]
    if program.env['ENABLE_STATIC_NS3']:
        if sys.platform == 'darwin':
            program.env.append_value('LINKFLAGS', '-Wl,-all_load')
            program.env.append_value('LINKFLAGS', '-lns3')
        else:
            program.env.append_value('LINKFLAGS', '-Wl,--whole-archive,-Bstatic')
            program.env.append_value('LINKFLAGS', '-lns3')
            program.env.append_value('LINKFLAGS', '-Wl,-Bdynamic,--no-whole-archive')
    return program

def add_examples_programs(bld):
    env = bld.env_of_name('default')
    if env['ENABLE_EXAMPLES']:
        for dir in os.listdir('examples'):
            if dir.startswith('.') or dir == 'CVS':
                continue
            if os.path.isdir(os.path.join('examples', dir)):
                bld.add_subdirs(os.path.join('examples', dir))


def add_scratch_programs(bld):
    all_modules = [mod[len("ns3-"):] for mod in bld.env['NS3_MODULES']]
    for filename in os.listdir("scratch"):
        if filename.startswith('.') or filename == 'CVS':
	    continue
        if os.path.isdir(os.path.join("scratch", filename)):
            obj = bld.create_ns3_program(filename, all_modules)
            obj.path = obj.path.find_dir('scratch').find_dir(filename)
            obj.find_sources_in_dirs('.')
            obj.target = filename
            obj.name = obj.target
        elif filename.endswith(".cc"):
            name = filename[:-len(".cc")]
            obj = bld.create_ns3_program(name, all_modules)
            obj.path = obj.path.find_dir('scratch')
            obj.source = filename
            obj.target = name
            obj.name = obj.target


def build(bld):
    wutils.bld = bld
    if Options.options.no_task_lines:
        import Runner
        def null_printout(s):
            pass
        Runner.printout = null_printout

    Options.cwd_launch = bld.path.abspath()
    bld.create_ns3_program = types.MethodType(create_ns3_program, bld)
    bld.create_suid_program = types.MethodType(create_suid_program, bld)

    # switch default variant to the one matching our debug level
    variant_name = bld.env_of_name('default')['NS3_ACTIVE_VARIANT']
    variant_env = bld.env_of_name(variant_name)
    bld.all_envs['default'] = variant_env

    # process subfolders from here
    bld.add_subdirs('src')
    bld.add_subdirs('samples')
    bld.add_subdirs('utils')

    add_examples_programs(bld)
    add_scratch_programs(bld)

    ## if --enabled-modules option was given, we disable building the
    ## modules that were not enabled, and programs that depend on
    ## disabled modules.
    env = bld.env

    if Options.options.enable_modules:
        Logs.warn("the option --enable-modules is being applied to this build only;"
                       " to make it permanent it needs to be given to waf configure.")
        env['NS3_ENABLED_MODULES'] = ['ns3-'+mod for mod in
                                      Options.options.enable_modules.split(',')]

    if env['NS3_ENABLED_MODULES']:
        modules = env['NS3_ENABLED_MODULES']
        changed = True
        while changed:
            changed = False
            for module in modules:
                module_obj = Object.name_to_obj(module)
                if module_obj is None:
                    raise ValueError("module %s not found" % module)
                for dep in module_obj.add_objects:
                    if not dep.startswith('ns3-'):
                        continue
                    if dep not in modules:
                        modules.append(dep)
                        changed = True

        ## remove objects that depend on modules not listed
        for obj in list(bld.all_task_gen):
            if hasattr(obj, 'ns3_module_dependencies'):
                for dep in obj.ns3_module_dependencies:
                    if dep not in modules:
                        bld.all_task_gen.remove(obj)
                        break
            if obj.name in env['NS3_MODULES'] and obj.name not in modules:
                bld.all_task_gen.remove(obj)

    ## Create a single ns3 library containing all enabled modules
    if env['ENABLE_STATIC_NS3']:
        lib = bld.new_task_gen('cxx', 'staticlib')
        lib.name = 'ns3'
        lib.target = 'ns3'
    else:
        lib = bld.new_task_gen('cxx', 'shlib')
        lib.name = 'ns3'
        lib.target = 'ns3'
        if lib.env['CXX_NAME'] in ['gcc', 'icc'] and env['WL_SONAME_SUPPORTED']:
            lib.env.append_value('LINKFLAGS', '-Wl,--soname=%s' % ccroot.get_target_name(lib))
        if sys.platform == 'cygwin':
            lib.features.append('implib') # workaround for WAF bug #472

    if env['NS3_ENABLED_MODULES']:
        lib.add_objects = list(modules)
        env['NS3_ENABLED_MODULES'] = list(modules)
        lib.uselib_local = list(modules)
    else:
        lib.add_objects = list(env['NS3_MODULES'])
        lib.uselib_local = list(env['NS3_MODULES'])

    bld.add_subdirs('bindings/python')

    if Options.options.run:
        # Check that the requested program name is valid
        program_name, dummy_program_argv = wutils.get_run_program(Options.options.run, wutils.get_command_template(env))

        # When --run'ing a program, tell WAF to only build that program,
        # nothing more; this greatly speeds up compilation when all you
        # want to do is run a test program.
        Options.options.compile_targets += ',' + os.path.basename(program_name)
        for gen in bld.all_task_gen:
            if type(gen).__name__ in ['ns3header_taskgen', 'ns3moduleheader_taskgen']:
                gen.post()

    if Options.options.regression or Options.options.regression_generate:
        regression_traces = env['REGRESSION_TRACES']
        if not regression_traces:
            raise Utils.WafError("Cannot run regression tests: reference traces directory not given"
                                 " (--with-regression-traces configure option)")

        if env['ENABLE_EXAMPLES'] == True:
            regression.run_regression(bld, regression_traces)
        else:
            raise Utils.WafError("Cannot run regression tests: building the ns-3 examples is not enabled"
                                 " (regression tests are based on examples)")


    if Options.options.doxygen_no_build:
        _doxygen(bld)
        raise SystemExit(0)

def shutdown(ctx):
    bld = wutils.bld
    if wutils.bld is None:
        return
    env = bld.env

    if Options.options.lcov_report:
        lcov_report()

    if Options.options.run:
        wutils.run_program(Options.options.run, env, wutils.get_command_template(env))
        raise SystemExit(0)

    if Options.options.pyrun:
        wutils.run_python_program(Options.options.pyrun, env)
        raise SystemExit(0)

    if Options.options.shell:
        raise Utils.WafError("Please run `./waf shell' now, instead of `./waf --shell'")

    if Options.options.check:
        raise Utils.WafError("Please run `./test.py' now, instead of `./waf --check'")

    check_shell(bld)

check_context = Build.BuildContext

def check(bld):
    """run the equivalent of the old ns-3 unit tests using test.py"""
    env = wutils.bld.env
    wutils.run_python_program("test.py -n -c core", env)

class print_introspected_doxygen_task(Task.TaskBase):
    after = 'cc cxx cc_link cxx_link'
    color = 'BLUE'

    def __init__(self, bld):
        self.bld = bld
        super(print_introspected_doxygen_task, self).__init__(generator=self)
        
    def __str__(self):
        return 'print-introspected-doxygen\n'

    def runnable_status(self):
        return Task.RUN_ME

    def run(self):
        ## generate the trace sources list docs
        env = wutils.bld.env
        proc_env = wutils.get_proc_env()
        try:
            program_obj = wutils.find_program('print-introspected-doxygen', env)
        except ValueError: # could happen if print-introspected-doxygen is
                           # not built because of waf configure
                           # --enable-modules=xxx
            pass
        else:
            prog = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj)).abspath(env)
            out = open(os.path.join('..', 'doc', 'introspected-doxygen.h'), 'w')
            if subprocess.Popen([prog], stdout=out, env=proc_env).wait():
                raise SystemExit(1)
            out.close()

class run_python_unit_tests_task(Task.TaskBase):
    after = 'cc cxx cc_link cxx_link'
    color = 'BLUE'

    def __init__(self, bld):
        self.bld = bld
        super(run_python_unit_tests_task, self).__init__(generator=self)
        
    def __str__(self):
        return 'run-python-unit-tests\n'

    def runnable_status(self):
        return Task.RUN_ME

    def run(self):
        proc_env = wutils.get_proc_env()
        wutils.run_argv([self.bld.env['PYTHON'], os.path.join("..", "utils", "python-unit-tests.py")],
                        self.bld.env, proc_env, force_no_valgrind=True)

def check_shell(bld):
    if ('NS3_MODULE_PATH' not in os.environ) or ('NS3_EXECUTABLE_PATH' not in os.environ):
        return
    env = bld.env
    correct_modpath = os.pathsep.join(env['NS3_MODULE_PATH'])
    found_modpath = os.environ['NS3_MODULE_PATH']
    correct_execpath = os.pathsep.join(env['NS3_EXECUTABLE_PATH'])
    found_execpath = os.environ['NS3_EXECUTABLE_PATH']
    if (found_modpath != correct_modpath) or (correct_execpath != found_execpath):
        msg = ("Detected shell (./waf shell) with incorrect configuration\n"
               "=========================================================\n"
               "Possible reasons for this problem:\n"
               "  1. You switched to another ns-3 tree from inside this shell\n"
               "  2. You switched ns-3 debug level (waf configure --debug)\n"
               "  3. You modified the list of built ns-3 modules\n"
               "You should correct this situation before running any program.  Possible solutions:\n"
               "  1. Exit this shell, and start a new one\n"
               "  2. Run a new nested shell")
        raise Utils.WafError(msg)


shell_context = Build.BuildContext
def shell(ctx):
    """run a shell with an environment suitably modified to run locally built programs"""

    #make sure we build first"
    Scripting.build(ctx)

    if sys.platform == 'win32':
        shell = os.environ.get("COMSPEC", "cmd.exe")
    else:
        shell = os.environ.get("SHELL", "/bin/sh")

    env = wutils.bld.env
    os_env = {'NS3_MODULE_PATH': os.pathsep.join(env['NS3_MODULE_PATH']), 'NS3_EXECUTABLE_PATH': os.pathsep.join(env['NS3_EXECUTABLE_PATH'])}
    wutils.run_argv([shell], env, os_env)

def _doxygen(bld):
    env = wutils.bld.env
    proc_env = wutils.get_proc_env()

    try:
        program_obj = wutils.find_program('print-introspected-doxygen', env)
    except ValueError: 
        Logs.warn("print-introspected-doxygen does not exist")
        raise SystemExit(1)
        return

    prog = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj)).abspath(env)

    if not os.path.exists(prog):
        Logs.error("print-introspected-doxygen has not been built yet."
                   " You need to build ns-3 at least once before "
                   "generating doxygen docs...")
        raise SystemExit(1)

    out = open(os.path.join('doc', 'introspected-doxygen.h'), 'w')

    if subprocess.Popen([prog], stdout=out, env=proc_env).wait():
        raise SystemExit(1)
    out.close()

    doxygen_config = os.path.join('doc', 'doxygen.conf')
    if subprocess.Popen(['doxygen', doxygen_config]).wait():
        raise SystemExit(1)

def doxygen(bld):
    """do a full build, generate the introspected doxygen and then the doxygen"""
    Scripting.build(bld)
    _doxygen(bld)

def lcov_report():
    env = Build.bld.env
    variant_name = env['NS3_ACTIVE_VARIANT']

    if 'gcov' not in variant_name:
        raise Utils.WafError("project not configured for code coverage;"
                     " reconfigure with --enable-gcov")

    os.chdir(blddir)
    try:
        lcov_report_dir = os.path.join(variant_name, 'lcov-report')
        create_dir_command = "rm -rf " + lcov_report_dir
        create_dir_command += " && mkdir " + lcov_report_dir + ";"

        if subprocess.Popen(create_dir_command, shell=True).wait():
            raise SystemExit(1)

        info_file = os.path.join(lcov_report_dir, variant_name + '.info')
        lcov_command = "../utils/lcov/lcov -c -d . -o " + info_file
        lcov_command += " --source-dirs=" + os.getcwd()
        lcov_command += ":" + os.path.join(
            os.getcwd(), variant_name, 'include')
        if subprocess.Popen(lcov_command, shell=True).wait():
            raise SystemExit(1)

        genhtml_command = "../utils/lcov/genhtml -o " + lcov_report_dir
        genhtml_command += " " + info_file
        if subprocess.Popen(genhtml_command, shell=True).wait():
            raise SystemExit(1)
    finally:
        os.chdir("..")

##
## The default WAF DistDir implementation is rather slow, because it
## first copies everything and only later removes unwanted files and
## directories; this means that it needless copies the full build dir
## and the .hg repository tree.  Here we provide a replacement DistDir
## implementation that is more efficient.
##
import Scripting
from Scripting import dist_exts, excludes, BLDDIR
import Utils
import os

def _copytree(src, dst, symlinks=False, excludes=(), build_dir=None):
    """Recursively copy a directory tree using copy2().

    The destination directory must not already exist.
    If exception(s) occur, an Error is raised with a list of reasons.

    If the optional symlinks flag is true, symbolic links in the
    source tree result in symbolic links in the destination tree; if
    it is false, the contents of the files pointed to by symbolic
    links are copied.

    XXX Consider this example code rather than the ultimate tool.

    Note: this is a modified version of shutil.copytree from python
    2.5.2 library; modified for WAF purposes to exclude dot dirs and
    another list of files.
    """
    names = os.listdir(src)
    os.makedirs(dst)
    errors = []
    for name in names:
        srcname = os.path.join(src, name)
        dstname = os.path.join(dst, name)
        try:
            if symlinks and os.path.islink(srcname):
                linkto = os.readlink(srcname)
                os.symlink(linkto, dstname)
            elif os.path.isdir(srcname):
                if name in excludes:
                    continue
                elif name.startswith('.') or name.startswith(',,') or name.startswith('++') or name.startswith('CVS'):
                    continue
                elif name == build_dir:
                    continue
                else:
                    ## build_dir is not passed into the recursive
                    ## copytree, but that is intentional; it is a
                    ## directory name valid only at the top level.
                    copytree(srcname, dstname, symlinks, excludes)
            else:
                ends = name.endswith
                to_remove = False
                if name.startswith('.') or name.startswith('++'):
                    to_remove = True
                else:
                    for x in dist_exts:
                        if ends(x):
                            to_remove = True
                            break
                if not to_remove:
                    shutil.copy2(srcname, dstname)
            # XXX What about devices, sockets etc.?
        except (IOError, os.error), why:
            errors.append((srcname, dstname, str(why)))
        # catch the Error from the recursive copytree so that we can
        # continue with other files
        except shutil.Error, err:
            errors.extend(err.args[0])
    try:
        shutil.copystat(src, dst)
    except WindowsError:
        # can't copy file access times on Windows
        pass
    except OSError, why:
        errors.extend((src, dst, str(why)))
    if errors:
        raise shutil.Error, errors


def DistDir(appname, version):
    #"make a distribution directory with all the sources in it"
    import shutil

    # Our temporary folder where to put our files
    TMPFOLDER=appname+'-'+version

    # Remove an old package directory
    if os.path.exists(TMPFOLDER): shutil.rmtree(TMPFOLDER)

    global g_dist_exts, g_excludes

    # Remove the Build dir
    build_dir = getattr(Utils.g_module, BLDDIR, None)

    # Copy everything into the new folder
    _copytree('.', TMPFOLDER, excludes=excludes, build_dir=build_dir)

    # TODO undocumented hook
    dist_hook = getattr(Utils.g_module, 'dist_hook', None)
    if dist_hook:
        os.chdir(TMPFOLDER)
        try:
            dist_hook()
        finally:
            # go back to the root directory
            os.chdir('..')
    return TMPFOLDER

Scripting.DistDir = DistDir