## -*- 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('--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('--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=('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)

    # 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'] in ['gcc', 'icc']:

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

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