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

# python lib modules

from __future__ import print_function

import sys

import shutil

import types

import optparse

import os.path

import re

import shlex

import subprocess

import textwrap

from utils import read_config_file

# WAF modules

from waflib import Utils, Scripting, Configure, Build, Options, TaskGen, Context, Task, Logs, Errors

from waflib.Errors import WafError

# local modules

import wutils

# By default, all modules will be enabled, examples will be disabled,

# and tests will be disabled.

modules_enabled  = ['all_modules']

examples_enabled = False

tests_enabled    = False

# GCC minimum version requirements for C++11 support

gcc_min_version = (4, 9, 2)

# Bug 2181:  clang warnings about unused local typedefs and potentially

# evaluated expressions affecting darwin clang/LLVM version 7.0.0 (Xcode 7)

# or clang/LLVM version 3.6 or greater.  We must make this platform-specific.

darwin_clang_version_warn_unused_local_typedefs = (7, 0, 0)

darwin_clang_version_warn_potentially_evaluated = (7, 0, 0)

clang_version_warn_unused_local_typedefs = (3, 6, 0)

clang_version_warn_potentially_evaluated = (3, 6, 0)

# Get the information out of the NS-3 configuration file.

config_file_exists = False

(config_file_exists, modules_enabled, examples_enabled, tests_enabled) = read_config_file()

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'

Configure.autoconfig = 0

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

VERSION = open("VERSION", "rt").read().strip()

APPNAME = 'ns'

wutils.VERSION = VERSION

wutils.APPNAME = APPNAME

# we don't use VNUM anymore (see bug #1327 for details)

wutils.VNUM = None

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

top = '.'

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

# Print the sorted list of module names in columns.

def print_module_names(names):

    # Sort the list of module names.

    names.sort()

    # Print the list of module names in 3 columns.

    i = 1

    for name in names:

        print(name.ljust(25), end=' ')

        if i == 3:

                print()

                i = 0

        i = i+1

    if i != 1:

        print()

# return types of some APIs differ in Python 2/3 (type string vs class bytes)

# This method will decode('utf-8') a byte object in Python 3, 

# and do nothing in Python 2

def maybe_decode(input):

    if sys.version_info < (3,):

        return input

    else:

        try:

            return input.decode('utf-8')

        except:

            sys.exc_clear()

            return input

def options(opt):

    # options provided by the modules

    opt.load('compiler_c')

    opt.load('compiler_cxx')

    opt.load('cflags')

    opt.load('gnu_dirs')

    opt.add_option('--check-config',

                   help=('Print the current configuration.'),

                   action="store_true", default=False,

                   dest="check_config")

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

                   help=('Modify --run arguments to enable the visualizer'),

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

    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-tests',

                   help=('Build the ns-3 tests.'),

                   dest='enable_tests', action='store_true',

                   default=False)

    opt.add_option('--disable-tests',

                   help=('Do not build the ns-3 tests.'),

                   dest='disable_tests', action='store_true',

                   default=False)

    opt.add_option('--enable-examples',

                   help=('Build the ns-3 examples.'),

                   dest='enable_examples', action='store_true',

                   default=False)

    opt.add_option('--disable-examples',

                   help=('Do not build the ns-3 examples.'),

                   dest='disable_examples', action='store_true',

                   default=False)

    opt.add_option('--check',

                   help=('DEPRECATED (run ./test.py)'),

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

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

    opt.add_option('--enable-des-metrics',

                   help=('Log all events in a json file with the name of the executable (which must call CommandLine::Parse(argc, argv)'),

                   action="store_true", default=False,

                   dest='enable_desmetrics')

    opt.add_option('--cxx-standard',

                   help=('Compile NS-3 with the given C++ standard'),

                   type='string', default='-std=c++11', dest='cxx_standard')

    # options provided in subdirectories

    opt.recurse('src')

    opt.recurse('bindings/python')

    opt.recurse('src/internet')

    opt.recurse('contrib')

def _check_compilation_flag(conf, flag, mode='cxx', linkflags=None):

    """

    Checks if the C++ compiler accepts a certain compilation flag or flags

    flag: can be a string or a list of strings

    """

    l = []

    if flag:

        l.append(flag)

    if isinstance(linkflags, list):

        l.extend(linkflags)

    else:

        if linkflags:

            l.append(linkflags)

    if len(l) > 1:

        flag_str = 'flags ' + ' '.join(l)

    else:

        flag_str = 'flag ' + ' '.join(l)

    if len(flag_str) > 28:

        flag_str = flag_str[:28] + "..."

    conf.start_msg('Checking for compilation %s support' % (flag_str,))

    env = conf.env.derive()

    retval = False

    if mode == 'cc':

        mode = 'c'

    if mode == 'cxx':

        env.append_value('CXXFLAGS', flag)

    else:

        env.append_value('CFLAGS', flag)

    if linkflags is not None:

        env.append_value("LINKFLAGS", linkflags)

    try:

        retval = conf.check(compiler=mode, fragment='int main() { return 0; }', features='c', env=env)

    except Errors.ConfigurationError:

        ok = False

    else:

        ok = (retval == True)

    conf.end_msg(ok)

    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 check_optional_feature(conf, name):

    for (name1, caption, was_enabled, reason_not_enabled) in conf.env.NS3_OPTIONAL_FEATURES:

        if name1 == name:

            return was_enabled

    raise KeyError("Feature %r not declared yet" % (name,))

# starting with waf 1.6, conf.check() becomes fatal by default if the

# test fails, this alternative method makes the test non-fatal, as it

# was in waf <= 1.5

def _check_nonfatal(conf, *args, **kwargs):

    try:

        return conf.check(*args, **kwargs)

    except conf.errors.ConfigurationError:

        return None

# Write a summary of optional features status

def print_config(env, phase='configure'):

    if phase == 'configure':

        profile = get_build_profile(env)

    else:

        profile = get_build_profile()

    print("---- Summary of optional NS-3 features:")

    print("%-30s: %s%s%s" % ("Build profile", Logs.colors('GREEN'),

                             profile, Logs.colors('NORMAL')))

    bld = wutils.bld

    print("%-30s: %s%s%s" % ("Build directory", Logs.colors('GREEN'),

                             Options.options.out, Logs.colors('NORMAL')))

    for (name, caption, was_enabled, reason_not_enabled) in sorted(env['NS3_OPTIONAL_FEATURES'], key=lambda s : s[1]):

        if was_enabled:

            status = 'enabled'

            color = 'GREEN'

        else:

            status = 'not enabled (%s)' % reason_not_enabled

            color = 'RED'

        print("%-30s: %s%s%s" % (caption, Logs.colors(color), status, Logs.colors('NORMAL')))

def configure(conf):

    conf.load('relocation', tooldir=['waf-tools'])

    # attach some extra methods

    conf.check_nonfatal = types.MethodType(_check_nonfatal, conf)

    conf.check_compilation_flag = types.MethodType(_check_compilation_flag, conf)

    conf.report_optional_feature = types.MethodType(report_optional_feature, conf)

    conf.check_optional_feature = types.MethodType(check_optional_feature, conf)

    conf.env['NS3_OPTIONAL_FEATURES'] = []

    conf.load('compiler_c')

    cc_string = '.'.join(conf.env['CC_VERSION'])

    conf.msg('Checking for cc version',cc_string,'GREEN')

    conf.load('compiler_cxx')

    conf.load('cflags', tooldir=['waf-tools'])

    conf.load('command', tooldir=['waf-tools'])

    conf.load('gnu_dirs')

    conf.load('clang_compilation_database', tooldir=['waf-tools'])

    env = conf.env

    if Options.options.enable_gcov:

        env['GCOV_ENABLED'] = True

        env.append_value('CCFLAGS', '-fprofile-arcs')

        env.append_value('CCFLAGS', '-ftest-coverage')

        env.append_value('CXXFLAGS', '-fprofile-arcs')

        env.append_value('CXXFLAGS', '-ftest-coverage')

        env.append_value('LINKFLAGS', '-lgcov')

        env.append_value('LINKFLAGS', '-coverage')

    if Options.options.build_profile == 'debug':

        env.append_value('DEFINES', 'NS3_BUILD_PROFILE_DEBUG')

        env.append_value('DEFINES', 'NS3_ASSERT_ENABLE')

        env.append_value('DEFINES', 'NS3_LOG_ENABLE')

    if Options.options.build_profile == 'release':

        env.append_value('DEFINES', 'NS3_BUILD_PROFILE_RELEASE')

    if Options.options.build_profile == 'optimized':

        env.append_value('DEFINES', 'NS3_BUILD_PROFILE_OPTIMIZED')

    env['PLATFORM'] = sys.platform

    env['BUILD_PROFILE'] = Options.options.build_profile

    if Options.options.build_profile == "release":

        env['BUILD_SUFFIX'] = ''

    else:

        env['BUILD_SUFFIX'] = '-'+Options.options.build_profile

    env['APPNAME'] = wutils.APPNAME

    env['VERSION'] = wutils.VERSION

    if conf.env['CXX_NAME'] in ['gcc']:

        if tuple(map(int, conf.env['CC_VERSION'])) < gcc_min_version:

            conf.fatal('gcc version %s older than minimum supported version %s' %

                       ('.'.join(conf.env['CC_VERSION']), '.'.join(map(str, gcc_min_version))))

    if conf.env['CXX_NAME'] in ['gcc', 'icc']:

        if Options.options.build_profile == 'release': 

            env.append_value('CXXFLAGS', '-fomit-frame-pointer') 

        if Options.options.build_profile == 'optimized': 

            if conf.check_compilation_flag('-march=native'):

                env.append_value('CXXFLAGS', '-march=native') 

            env.append_value('CXXFLAGS', '-fstrict-overflow')

            if conf.env['CXX_NAME'] in ['gcc']:

                env.append_value('CXXFLAGS', '-Wstrict-overflow=2')

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

        cxx_check_libstdcxx = cxx + ['-print-file-name=libstdc++.so']

        p = subprocess.Popen(cxx_check_libstdcxx, stdout=subprocess.PIPE)

        libstdcxx_output = maybe_decode(p.stdout.read().strip())

        libstdcxx_location = os.path.dirname(libstdcxx_output)

        p.wait()

        if libstdcxx_location:

            conf.env.append_value('NS3_MODULE_PATH', libstdcxx_location)

        if Utils.unversioned_sys_platform() in ['linux']:

            if conf.check_compilation_flag('-Wl,--soname=foo'):

                env['WL_SONAME_SUPPORTED'] = True

    # bug 2181 on clang warning suppressions

    if conf.env['CXX_NAME'] in ['clang']:

        if Utils.unversioned_sys_platform() == 'darwin':

            if tuple(map(int, conf.env['CC_VERSION'])) >= darwin_clang_version_warn_unused_local_typedefs:

                env.append_value('CXXFLAGS', '-Wno-unused-local-typedefs')

            if tuple(map(int, conf.env['CC_VERSION'])) >= darwin_clang_version_warn_potentially_evaluated:

                env.append_value('CXXFLAGS', '-Wno-potentially-evaluated-expression')

        else:

            if tuple(map(int, conf.env['CC_VERSION'])) >= clang_version_warn_unused_local_typedefs:

                env.append_value('CXXFLAGS', '-Wno-unused-local-typedefs')

            if tuple(map(int, conf.env['CC_VERSION'])) >= clang_version_warn_potentially_evaluated:

                env.append_value('CXXFLAGS', '-Wno-potentially-evaluated-expression')

    env['ENABLE_STATIC_NS3'] = False

    if Options.options.enable_static:

        if Utils.unversioned_sys_platform() == 'darwin':

            if conf.check_compilation_flag(flag=[], linkflags=['-Wl,-all_load']):

                conf.report_optional_feature("static", "Static build", True, '')

                env['ENABLE_STATIC_NS3'] = True

            else:

                conf.report_optional_feature("static", "Static build", False,

                                             "Link flag -Wl,-all_load does not work")

        else:

            if conf.check_compilation_flag(flag=[], linkflags=['-Wl,--whole-archive,-Bstatic', '-Wl,-Bdynamic,--no-whole-archive']):

                conf.report_optional_feature("static", "Static build", True, '')

                env['ENABLE_STATIC_NS3'] = True

            else:

                conf.report_optional_feature("static", "Static build", False,

                                             "Link flag -Wl,--whole-archive,-Bstatic does not work")

    # Enables C++-11 support by default, unless user specified another option

    # Warn the user if the CXX Standard flag provided was not recognized  

    if conf.check_compilation_flag(Options.options.cxx_standard):

        env.append_value('CXXFLAGS', Options.options.cxx_standard)

    else:

        Logs.warn("CXX Standard flag " + Options.options.cxx_standard + " was not recognized, using compiler's default")

    # Set this so that the lists won't be printed at the end of this

    # configure command.

    conf.env['PRINT_BUILT_MODULES_AT_END'] = False

    conf.env['MODULES_NOT_BUILT'] = []

    conf.recurse('bindings/python')

    conf.recurse('src')

    conf.recurse('contrib')

    # Set the list of enabled modules.

    if Options.options.enable_modules:

        # Use the modules explicitly enabled. 

        _enabled_mods = []

        _enabled_contrib_mods = []

        for mod in Options.options.enable_modules.split(','): 

            if mod in conf.env['NS3_MODULES'] and mod.startswith('ns3-'): 

                _enabled_mods.append(mod)

            elif 'ns3-' + mod in conf.env['NS3_MODULES']: 

                _enabled_mods.append('ns3-' + mod)

            elif mod in conf.env['NS3_CONTRIBUTED_MODULES'] and mod.startswith('ns3-'): 

                _enabled_contrib_mods.append(mod)

            elif 'ns3-' + mod in conf.env['NS3_CONTRIBUTED_MODULES']: