## -*- 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

 import cflags # override the build profiles from waf

 cflags.profiles = {

 	# profile name: [optimization_level, warnings_level, debug_level]

 	'debug':     [0, 2, 3],

 	'optimized': [3, 2, 1],

 	}

 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_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('--doxygen',

                    help=('Run doxygen to generate html documentation from source comments'),

                    action="store_true", default=False,

                    dest='doxygen')

     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('--regression',

                    help=("Enable regression testing; only used for the 'check' target"),

                    default=False, dest='regression', action="store_true")

     opt.add_option('--check',

                    help=("Enable unit testing"),

                    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)

     # options provided in a script in a subdirectory named "src"

     opt.sub_options('src')

     opt.sub_options('bindings/python')

     opt.sub_options('src/internet-stack')

 def _check_compilation_flag(conf, flag):

     """

     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()

     env.append_value('CXXFLAGS', flag)

     try:

         retval = conf.run_c_code(code='#include <stdio.h>\nint main() { return 0; }\n',

                                  env=env, compile_filename='test.cc',

                                  compile_mode='cxx',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_cxx')

     conf.check_tool('cflags')

     try:

         conf.check_tool('pkgconfig')

     except Configure.ConfigurationError:

         pass

     conf.check_tool('command')

     # 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

     env.append_value('CXXDEFINES', 'RUN_SELF_TESTS')

     if env['COMPILER_CXX'] == 'g++' and 'CXXFLAGS' not in os.environ:

         if conf.check_compilation_flag('-Wno-error=deprecated-declarations'):

             env.append_value('CXXFLAGS', '-Wno-error=deprecated-declarations')

     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'] == 'gcc':

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

     # 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'] == 'gcc':

             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")

     # 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_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 utils examples')

     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'] == 'gcc' 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.

         if not Options.options.compile_targets:

             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)")

         regression.run_regression(bld, regression_traces)

     if Options.options.check:

         _run_check(bld)

 def shutdown(ctx):

     bld = wutils.bld

     if wutils.bld is None:

         return

     env = bld.env

     #if Options.commands['check']:

     #    _run_waf_check()

     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("Run `./waf shell' now, instead of `./waf shell'")

     if Options.options.doxygen:

         doxygen()

         raise SystemExit(0)

     check_shell(bld)

     if Options.options.doxygen:

         doxygen()

         raise SystemExit(0)

 check_context = Build.BuildContext

 def check(bld):

     """run the NS-3 unit tests (deprecated in favour of --check option)"""

     raise Utils.WafError("Please run `./waf --check' instead.")

 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)

 class run_a_unit_test_task(Task.TaskBase):

     after = 'cc cxx cc_link cxx_link'

     color = 'BLUE'

     def __init__(self, bld, name_of_test):

         self.bld = bld

         super(run_a_unit_test_task, self).__init__(generator=self)

         self.name_of_test = name_of_test

         try:

             program_obj = wutils.find_program("run-tests", self.bld.env)

         except ValueError, ex:

             raise Utils.WafError(str(ex))

         program_node = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj))

         self.program_path = program_node.abspath(self.bld.env)

     def __str__(self):

         return 'run-unit-test(%s)\n' % self.name_of_test

     def runnable_status(self):

         return Task.RUN_ME

     def run(self):

         #print repr([self.program_path, self.name_of_test])

         try:

             self.retval = wutils.run_argv([self.program_path, self.name_of_test], self.bld.env)

         except Utils.WafError:

             self.retval = 1

         #print "running test %s: exit with %i" % (self.name_of_test, retval)

         return 0

 class get_list_of_unit_tests_task(Task.TaskBase):

     after = 'cc cxx cc_link cxx_link'

     color = 'BLUE'

     def __init__(self, bld):

         self.bld = bld

         super(get_list_of_unit_tests_task, self).__init__(generator=self)

         self.tests = []

     def __str__(self):

         return 'get-unit-tests-list\n'

     def runnable_status(self):

         return Task.RUN_ME

     def run(self):

         try:

             program_obj = wutils.find_program("run-tests", self.bld.env)

         except ValueError, ex:

             raise Utils.WafError(str(ex))

         program_node = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj))

         program_path = program_node.abspath(self.bld.env)

         proc = subprocess.Popen([program_path, "--ListTests"], stdout=subprocess.PIPE,

                                 env=wutils.get_proc_env())

         self.tests = [l.rstrip() for l in proc.stdout.readlines()]

         retval = proc.wait()

         if retval:

             return retval

         test_tasks = []

         for name_of_test in self.tests:

             test_tasks.append(run_a_unit_test_task(self.bld, name_of_test))

         collector = collect_unit_test_results_task(self.bld, list(test_tasks))

         collector.run_after = list(test_tasks)

         self.more_tasks = [collector] + test_tasks

 class collect_unit_test_results_task(Task.TaskBase):

     after = 'run_a_unit_test_task'

     color = 'BLUE'

     def __init__(self, bld, test_tasks):

         self.bld = bld

         super(collect_unit_test_results_task, self).__init__(generator=self)

         self.test_tasks = test_tasks

     def __str__(self):

         return 'collect-unit-tests-results\n'

     def runnable_status(self):

         for t in self.run_after:

             if not t.hasrun:

                 return Task.ASK_LATER

         return Task.RUN_ME

     def run(self):

         failed_tasks = []

         for task in self.test_tasks:

             if task.retval:

                 failed_tasks.append(task)

         if failed_tasks:

             print "C++ UNIT TESTS: %i tests passed, %i failed (%s)." % \

                 (len(self.test_tasks) - len(failed_tasks), len(failed_tasks),

                  ', '.join(t.name_of_test for t in failed_tasks))

             return 1

         else:

             print "C++ UNIT TESTS: all %i tests passed." % (len(self.test_tasks),)

             return 0

 def _run_check(bld):

     task = get_list_of_unit_tests_task(bld)

     print_introspected_doxygen_task(bld)

     if bld.env['ENABLE_PYTHON_BINDINGS']:

         run_python_unit_tests_task(bld)

 def check_shell(bld):

     if 'NS3_MODULE_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']

     if found_modpath != correct_modpath:

         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

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

 def doxygen():

     if not os.path.exists('doc/introspected-doxygen.h'):

         Logs.warn("doc/introspected-doxygen.h does not exist; run waf check to generate it.")

     ## run doxygen

     doxygen_config = os.path.join('doc', 'doxygen.conf')

     if subprocess.Popen(['doxygen', doxygen_config]).wait():

         raise SystemExit(1)

 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