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

import sys

import shlex

import shutil

import urllib

import types

import optparse

import os.path

import pproc as subprocess

import Params

import Object

import ccroot

Params.g_autoconfig = 1

# the following two variables are used by the target "waf dist"

VERSION = file("VERSION").read().strip()

APPNAME = 'ns'

# these variables are mandatory ('/' are converted automatically)

srcdir = '.'

blddir = 'build'

#

# The directory in which the tarball of the reference traces lives.  This is

# used if Mercurial is not on the system.

#

REGRESSION_TRACES_URL = "http://www.nsnam.org/releases/"

#

# The path to the Mercurial repository used to find the reference traces if

# we find "hg" on the system.  We expect that the repository will be named

# identically to refDirName below

#

REGRESSION_TRACES_REPO = "http://code.nsnam.org/"

#

# Name of the local directory where the regression code lives.

#

REGRESSION_DIR = "regression"

#

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

#

# The last part of the path name to use to find the regression traces tarball.

# path will be APPNAME + '-' + VERSION + REGRESSION_SUFFIX + TRACEBALL_SUFFIX,

# e.g., ns-3-dev-ref-traces.tar.bz2

#

TRACEBALL_SUFFIX = ".tar.bz2"

def dist_hook():

    import tarfile

    shutil.rmtree("doc/html", True)

    shutil.rmtree("doc/latex", True)

    shutil.rmtree("nsc", True)

    if not os.path.exists("bindings/python/pybindgen"):

        Params.fatal("Missing pybindgen checkout; run './waf configure --pybindgen-checkout' first.")

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

    traces_dir = os.path.join(REGRESSION_DIR, traces_name)

    if not os.path.isdir(traces_dir):

        Params.warning("Not creating traces archive: the %s directory does not exist" % traces_dir)

    else:

        traceball = traces_name + TRACEBALL_SUFFIX

        tar = tarfile.open(os.path.join("..", traceball), 'w:bz2')

        tar.add(traces_dir)

        tar.close()

        ## Now remove it; we do not ship the traces with the main tarball...

        shutil.rmtree(traces_dir, True)

def set_options(opt):

    def debug_option_callback(option, opt, value, parser):

        if value == 'debug':

            setattr(parser.values, option.dest, 'ultradebug')

        elif value == 'optimized':

            setattr(parser.values, option.dest, 'optimized')

        else:

            raise optparse.OptionValueError("allowed --debug-level values"

                                            " are debug, optimized.")

    opt.add_option('-d', '--debug-level',

                   action='callback',

                   type="string", dest='debug_level', default='ultradebug',

                   help=('Specify the debug level, does nothing if CFLAGS is set'

                         ' in the environment. [Allowed Values: debug, optimized].'

                         ' WARNING: this option only has effect '

                         'with the configure command.'),

                   callback=debug_option_callback)

    # options provided by the modules

    opt.tool_options('compiler_cxx')

    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=('Run a shell with an environment suitably modified to run locally built programs'),

                   action="store_true", default=False,

                   dest='shell')

    opt.add_option('--regression',

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

                   default=False, dest='regression', 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")

    # 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

    """

    # Check for -Wno-error=deprecated-declarations

    save_CXXFLAGS = list(conf.env['CXXFLAGS'])

    conf.env.append_value('CXXFLAGS', flag)

    e = conf.create_test_configurator()

    e.mandatory = 0

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

    e.want_message = 0

    ok = e.run()

    conf.check_message_custom(flag, 'compilation flag support',

                              (ok and 'yes' or 'no'))

    if not ok: # if it doesn't accept, remove it again

        conf.env['CXXFLAGS'] = save_CXXFLAGS

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

    conf.check_tool('compiler_cxx')

    # create the second environment, set the variant and set its name

    variant_env = conf.env.copy()

    debug_level = Params.g_options.debug_level.lower()

    if debug_level == 'ultradebug':

        variant_name = 'debug'

    else:

        variant_name = debug_level

    variant_env['INCLUDEDIR'] = os.path.join(variant_env['PREFIX'], 'include')

    if Params.g_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)

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

    if (os.path.basename(conf.env['CXX']).startswith("g++")

        and 'CXXFLAGS' not in os.environ):

        variant_env.append_value('CXXFLAGS', '-Werror')

        check_compilation_flag(conf, '-Wno-error=deprecated-declarations')

    if 'debug' in Params.g_options.debug_level.lower():

        variant_env.append_value('CXXDEFINES', 'NS3_ASSERT_ENABLE')

        variant_env.append_value('CXXDEFINES', 'NS3_LOG_ENABLE')

    ## In optimized builds we still want debugging symbols, e.g. for

    ## profiling, and at least partially usable stack traces.

    if ('optimized' in Params.g_options.debug_level.lower() 

        and 'CXXFLAGS' not in os.environ):

        for flag in variant_env['CXXFLAGS_DEBUG']:

            ## this probably doesn't work for MSVC

            if flag.startswith('-g'):

                variant_env.append_value('CXXFLAGS', flag)

    ## in optimized builds, replace -O2 with -O3

    if 'optimized' in Params.g_options.debug_level.lower():

        lst = variant_env['CXXFLAGS']

        for i, flag in enumerate(lst):

            if flag == '-O2':

                lst[i] = '-O3'

    if sys.platform == 'win32':

        if os.path.basename(conf.env['CXX']).startswith("g++"):

            variant_env.append_value("LINKFLAGS", "-Wl,--enable-runtime-pseudo-reloc")

    conf.sub_config('src')

    conf.sub_config('utils')

    conf.sub_config('bindings/python')

    if Params.g_options.enable_modules:

        conf.env['NS3_ENABLED_MODULES'] = ['ns3-'+mod for mod in

                                           Params.g_options.enable_modules.split(',')]

    # we cannot run regression tests without diff

    conf.find_program('diff', var='DIFF')

    # we cannot pull regression traces without mercurial

    conf.find_program('hg', var='MERCURIAL')

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

def create_ns3_program(bld, name, dependencies=('simulator',)):

    program = bld.create_obj('cpp', '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]

    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 os.path.isdir(os.path.join("scratch", filename)):

            obj = bld.create_ns3_program(filename, all_modules)

            obj.path = obj.path.find_dir('scratch')

            obj.find_sources_in_dirs(filename)

            obj.target = os.path.join(filename, filename)

        elif filename.endswith(".cc"):

            name = filename[:-len(".cc")]

            obj = bld.create_ns3_program(name, all_modules)

            obj.source = "scratch/%s" % filename

            obj.target = "scratch/%s" % name

##

## This replacement spawn function increases the maximum command line length to 32k

##

def _exec_command_interact_win32(s):

    if Params.g_verbose:

        print s

    startupinfo = subprocess.STARTUPINFO()

    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

    proc = subprocess.Popen(s, shell=False, startupinfo=startupinfo)

    stat = proc.wait()

    if stat & 0xff:

        return stat | 0x80

    return stat >> 8

def build(bld):

    if Params.g_options.no_task_lines:

        import Runner

        def null_printout(s):

            pass

        Runner.printout = null_printout

    if sys.platform == 'win32':

        import Runner

        Runner.exec_command = _exec_command_interact_win32

    Params.g_cwd_launch = Params.g_build.m_curdirnode.abspath()

    bld.create_ns3_program = types.MethodType(create_ns3_program, bld)

    variant_name = bld.env_of_name('default')['NS3_ACTIVE_VARIANT']

    variant_env = bld.env_of_name(variant_name)

    bld.m_allenvs['default'] = variant_env # switch to the active variant

    if Params.g_options.shell:

        run_shell()

        raise SystemExit(0)

    if Params.g_options.doxygen:

        doxygen()

        raise SystemExit(0)

    check_shell()

    if Params.g_options.doxygen:

        doxygen()

        raise SystemExit(0)

    print "Entering directory `%s'" % os.path.join(Params.g_build.m_curdirnode.abspath(), 'build')

    # 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 Params.g_options.enable_modules:

        Params.warning("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

                                      Params.g_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(Object.g_allobjs):

            if hasattr(obj, 'ns3_module_dependencies'):

                for dep in obj.ns3_module_dependencies:

                    if dep not in modules:

                        Object.g_allobjs.remove(obj)

                        break

            if obj.name in env['NS3_MODULES'] and obj.name not in modules:

                Object.g_allobjs.remove(obj)

    ## Create a single ns3 library containing all enabled modules

    lib = bld.create_obj('cpp', 'shlib')

    lib.name = 'ns3'

    lib.target = 'ns3'

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

def get_command_template(*arguments):

    if Params.g_options.valgrind:

        if Params.g_options.command_template:

            Params.fatal("Options --command-template and --valgrind are conflicting")

        cmd = "valgrind --leak-check=full %s"

    else:

        cmd = Params.g_options.command_template or '%s'

    for arg in arguments:

        cmd = cmd + " " + arg

    return cmd

def shutdown():

    #import UnitTest

    #ut = UnitTest.unit_test()

    #ut.change_to_testfile_dir = True

    #ut.want_to_see_test_output = True

    #ut.want_to_see_test_error = True

    #ut.run()

    #ut.print_results()

    env = Params.g_build.env_of_name('default')

    if Params.g_commands['check']:

        _run_waf_check()

    if Params.g_options.regression or Params.g_options.regression_generate:

        if not env['DIFF']:

            Params.fatal("Cannot run regression tests: the 'diff' program is not installed.")

        _dir = os.getcwd()

        os.chdir("regression")

        try:

            run_regression()

        finally:

            os.chdir(_dir)

    if Params.g_options.lcov_report:

        lcov_report()

    if Params.g_options.run:

        run_program(Params.g_options.run, get_command_template())

        raise SystemExit(0)

    if Params.g_options.pyrun:

        run_python_program(Params.g_options.pyrun)

        raise SystemExit(0)

def _run_waf_check():

    ## generate the trace sources list docs

    env = Params.g_build.env_of_name('default')

    proc_env = _get_proc_env()

    try:

        program_obj = _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_build(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()

    print "-- Running NS-3 C++ core unit tests..."

    run_program('run-tests', get_command_template())

    if env['ENABLE_PYTHON_BINDINGS']:

        print "-- Running NS-3 Python bindings unit tests..."

        _run_argv([env['PYTHON'], os.path.join("utils", "python-unit-tests.py")], proc_env)

    else:

        print "-- Skipping NS-3 Python bindings unit tests: Python bindings not enabled."