Attachment #1506 for bug #1562

View | Details | Raw Unified | Return to bug 1562
Collapse All | Expand All




import shutil
import sys

from waflib import Task, Options, Configure, TaskGen, Logs, Build, Utils, Errors
from waflib.Errors import WafError
import Configure
import TaskGen
import Logs
import Build
import Utils

feature  = TaskGen.feature
after = TaskGen.after

## https://launchpad.net/pybindgen/
REQUIRED_PYBINDGEN_VERSION = (0, 15, 0, 809)
REQUIRED_PYGCCXML_VERSION = (0, 9, 5)


from TaskGen import feature, after
import Task



def add_to_python_path(path):
    if os.environ.get('PYTHONPATH', ''):



def options(opt):
    opt.load('python')
    opt.add_option('--disable-python',
                   help=("Don't build Python bindings."),
                   action="store_true", default=False,

    available_modules.sort()
    all_modules_enabled = (enabled_modules == available_modules)

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

    if sys.platform == 'cygwin':
        conf.report_optional_feature("python", "Python Bindings", False,

        conf.env.PYTHON = Options.options.with_python

    try:
        conf.load('python')
    except Errors.ConfigurationError, ex:
        conf.report_optional_feature("python", "Python Bindings", False,
                                     "The python interpreter was not found")
        return
    try:
        conf.check_python_version((2,3))
    except Errors.ConfigurationError, ex:
        conf.report_optional_feature("python", "Python Bindings", False,
                                     "The python found version is too low (2.3 required)")
        return
    try:
        conf.check_python_headers()
    except Errors.ConfigurationError, ex:
        conf.report_optional_feature("python", "Python Bindings", False,
                                     "Python library or headers missing")
        return


    try:
        conf.check_python_module('pybindgen')
    except Errors.ConfigurationError:
        Logs.warn("pybindgen missing => no python bindings")
        conf.report_optional_feature("python", "Python Bindings", False,
                                     "PyBindGen missing")


        try:
            ret = conf.run_c_code(code=test_program,
                                  env=conf.env.derive(), compile_filename='test.cc',
                                  features='cxx cprogram', execute=False)
        except Errors.ConfigurationError:
            ret = 1
        conf.msg('Checking for types %s and %s equivalence' % (t1, t2), (ret and 'no' or 'yes'))
        return not ret

    ## Check for pygccxml
    try:
        conf.check_python_module('pygccxml')
    except Errors.ConfigurationError:
        conf.report_optional_feature("pygccxml", "Python API Scanning Support", False,
                                     "Missing 'pygccxml' Python module")
        return

    """Uses gccxml to scan the file 'everything.h' and extract API definitions.
    """
    after = 'gen_ns3_module_header ns3header'
    before = 'cxx command'
    color = "BLUE"
    def __init__(self, curdirnode, env, bld, target, cflags, module):
        self.bld = bld

    """Tasks that waits for the python-scan-* tasks to complete and then signals WAF to exit
    """
    after = 'apiscan'
    before = 'cxx'
    color = "BLUE"
    def __init__(self, curdirnode, env, bld):
        self.bld = bld


class gen_ns3_compat_pymod_task(Task.Task):
    """Generates a 'ns3.py' compatibility module."""
    before = 'cxx'
    color = 'BLUE'
    
    def run(self):

        return

    env = bld.env
    curdir = bld.path.abspath()

    set_pybindgen_pythonpath(env)

    if Options.options.apiscan:

        grp = bld.get_group(bld.current_group)
        grp.append(task)

        bld(features='copy', source="ns__init__.py", target='ns/__init__.py')
                         source="ns__init__.py",
                         target='ns/__init__.py')
        bld.install_as('${PYTHONARCHDIR}/ns/__init__.py', 'ns__init__.py')



(-)a/src/antenna/wscript (-1 / +1 lines)

Lines 21-27	Link Here

        'test/test-parabolic-antenna.cc',

        'test/test-parabolic-antenna.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'antenna'

    headers.module = 'antenna'

    headers.source = [

    headers.source = [

        'model/angles.h',

        'model/angles.h',

(-)a/src/aodv/wscript (-2 / +2 lines)

Lines 23-29	Link Here

        'test/loopback.cc',

        'test/loopback.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'aodv'

    headers.module = 'aodv'

    headers.source = [

    headers.source = [

        'model/aodv-id-cache.h',

        'model/aodv-id-cache.h',

Lines 37-42	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/applications/wscript (-1 / +1 lines)

Lines 32-38	Link Here

        'test/udp-client-server-test.cc',

        'test/udp-client-server-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'applications'

    headers.module = 'applications'

    headers.source = [

    headers.source = [

        'model/bulk-send-application.h',

        'model/bulk-send-application.h',

(-)a/src/bridge/wscript (-2 / +2 lines)

Lines 7-13	Link Here

        'model/bridge-channel.cc',

        'model/bridge-channel.cc',

        'helper/bridge-helper.cc',

        'helper/bridge-helper.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'bridge'

    headers.module = 'bridge'

    headers.source = [

    headers.source = [

        'model/bridge-net-device.h',

        'model/bridge-net-device.h',

Lines 16-21	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/brite/wscript (-3 / +5 lines)

Lines 1-6	Link Here

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

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

import os

import os

import Options

from waflib import Options

def options(opt):

def options(opt):

Lines 89-95	Link Here

    if bld.env['BRITE'] and bld.env['DL']:

    if bld.env['BRITE'] and bld.env['DL']:

        module.uselib = 'BRITE DL'

        module.uselib = 'BRITE DL'

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'brite'

    headers.module = 'brite'

    headers.source = [

    headers.source = [

Lines 100-103	Link Here

100

        module_test.source.append('test/brite-test-topology.cc')

102

        module_test.source.append('test/brite-test-topology.cc')

101

103

102

    if bld.env['ENABLE_EXAMPLES'] and bld.env['ENABLE_BRITE']:

104

    if bld.env['ENABLE_EXAMPLES'] and bld.env['ENABLE_BRITE']:

103

      bld.add_subdirs('examples')

105

      bld.recurse('examples')

(-)a/src/buildings/wscript (-2 / +2 lines)

Lines 25-31	Link Here

        'test/buildings-shadowing-test.cc',

        'test/buildings-shadowing-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'buildings'

    headers.module = 'buildings'

    headers.source = [

    headers.source = [

        'model/building.h',

        'model/building.h',

Lines 42-48	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()




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

import os

from waflib import Options


def options(opt):

        module.use.extend(['NSCLICK', 'DL'])
        module_test.use.extend(['NSCLICK', 'DL'])

    headers = bld(features='ns3header')
    headers.module = 'click'
    headers.source = [
        'model/ipv4-click-routing.h',

        ]

    if bld.env['ENABLE_EXAMPLES']:
        bld.recurse('examples')

    bld.ns3_python_bindings()





def configure(conf):
    if Options.options.disable_gtk:
        conf.env['ENABLE_GTK2'] = False
        conf.report_optional_feature("GtkConfigStore", "GtkConfigStore",
                                     conf.env['ENABLE_GTK2'],
                                     "--disable-gtk option given")
    else:
        have_gtk2 = conf.check_cfg(package='gtk+-2.0', atleast_version='2.12', 
                                   args=['--cflags', '--libs'], uselib_store='GTK2',
                                   mandatory=False)

        conf.env['ENABLE_GTK2'] = have_gtk2
        conf.report_optional_feature("GtkConfigStore", "GtkConfigStore",
                                     conf.env['ENABLE_GTK2'],
                                     "library 'gtk+-2.0 >= 2.12' not found")

    have_libxml2 = conf.check_cfg(package='libxml-2.0', atleast_version='2.7',
                                  args=['--cflags', '--libs'], uselib_store='LIBXML2',
                                  mandatory=False)

    conf.env['ENABLE_LIBXML2'] = have_libxml2
    conf.report_optional_feature("XmlIo", "XmlIo",
                                 conf.env['ENABLE_LIBXML2'],
                                 "library 'libxml-2.0 >= 2.7' not found")

    conf.write_config_header('ns3/config-store-config.h', top=True)



        'model/raw-text-config.cc',
        ]

    headers = bld(features='ns3header')
    headers.module = 'config-store'
    headers.source = [
        'model/file-config.h',
        'model/config-store.h',
        ]

    if bld.env['ENABLE_GTK2']:
        headers.source.append ('model/gtk-config-store.h')
        module.source.extend (['model/gtk-config-store.cc',
                               'model/model-node-creator.cc',
                               'model/model-typeid-creator.cc',
                               'model/display-functions.cc',
                               ])
        module.use.append('GTK2')

    if bld.env['ENABLE_LIBXML2']:
        module.source.append ('model/xml-config.cc')
        module.use.append('LIBXML2')

    if bld.env['ENABLE_EXAMPLES']:
        bld.recurse('examples')

    bld.ns3_python_bindings()




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

from waflib import Options

import wutils

def options(opt):

    conf.check_nonfatal(header_name='signal.h', define_name='HAVE_SIGNAL_H')

    # Check for POSIX threads
    test_env = conf.env.derive()
    if Options.platform != 'darwin' and Options.platform != 'cygwin':
        test_env.append_value('LINKFLAGS', '-pthread')
        test_env.append_value('CXXFLAGS', '-pthread')

        'test/watchdog-test-suite.cc',
        ]

    headers = bld(features='ns3header')
    headers.module = 'core'
    headers.source = [
        'model/nstime.h',

        core_test.source.extend(['test/rng-test-suite.cc'])

    if (bld.env['ENABLE_EXAMPLES']):
        bld.recurse('examples')

    pymod = bld.ns3_python_bindings()
    if pymod is not None:




    obj.source = [
        'model/csma-star-helper.cc',
        ]
    headers = bld(features='ns3header')
    headers.module = 'csma-layout'
    headers.source = [
        'model/csma-star-helper.h',
        ]

    if bld.env['ENABLE_EXAMPLES']:
        bld.recurse('examples')

    bld.ns3_python_bindings()


(-)a/src/csma/wscript (-2 / +2 lines)

Lines 8-14	Link Here

        'model/csma-channel.cc',

        'model/csma-channel.cc',

        'helper/csma-helper.cc',

        'helper/csma-helper.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'csma'

    headers.module = 'csma'

    headers.source = [

    headers.source = [

        'model/backoff.h',

        'model/backoff.h',

Lines 18-23	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/dsdv/wscript (-2 / +2 lines)

Lines 16-22	Link Here

        'test/dsdv-testcase.cc',

        'test/dsdv-testcase.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'dsdv'

    headers.module = 'dsdv'

    headers.source = [

    headers.source = [

        'model/dsdv-rtable.h',

        'model/dsdv-rtable.h',

Lines 26-31	Link Here

        'helper/dsdv-helper.h',

        'helper/dsdv-helper.h',

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

      bld.add_subdirs('examples')

      bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/dsr/wscript (-2 / +2 lines)

Lines 24-30	Link Here

        'test/dsr-test-suite.cc',

        'test/dsr-test-suite.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'dsr'

    headers.module = 'dsr'

    headers.source = [

    headers.source = [

        'model/dsr-routing.h',

        'model/dsr-routing.h',

Lines 43-48	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

      bld.add_subdirs('examples')

      bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/emu/wscript (-2 / +2 lines)

Lines 36-42	Link Here

            'helper/emu-helper.cc',

            'helper/emu-helper.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'emu'

    headers.module = 'emu'

    headers.source = [

    headers.source = [

            'model/emu-net-device.h',

            'model/emu-net-device.h',

Lines 52-57	Link Here

    module.env.append_value("DEFINES", "EMU_SOCK_CREATOR=\"%s\"" % (creator.target,))

    module.env.append_value("DEFINES", "EMU_SOCK_CREATOR=\"%s\"" % (creator.target,))

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/energy/wscript (-2 / +2 lines)

Lines 25-31	Link Here

        'test/li-ion-energy-source-test.cc',

        'test/li-ion-energy-source-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'energy'

    headers.module = 'energy'

    headers.source = [

    headers.source = [

        'model/wifi-radio-energy-model.h',

        'model/wifi-radio-energy-model.h',

Lines 44-49	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

      bld.add_subdirs('examples')

      bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/flow-monitor/wscript (-2 / +2 lines)

Lines 17-23	Link Here

        'test/histogram-test-suite.cc',

        'test/histogram-test-suite.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'flow-monitor'

    headers.module = 'flow-monitor'

    headers.source = ["model/%s" % s for s in [

    headers.source = ["model/%s" % s for s in [

       'flow-monitor.h',

       'flow-monitor.h',

Lines 30-35	Link Here

    headers.source.append("helper/flow-monitor-helper.h")

    headers.source.append("helper/flow-monitor-helper.h")

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()




import os
import sys

from waflib import Options, Logs, Utils, Task

import Utils
import Task

# Required NSC version
NSC_RELEASE_NAME = "nsc-0.5.3"

        'test/ipv6-address-helper-test-suite.cc',
        ]

    headers = bld(features='ns3header')
    headers.module = 'internet'
    headers.source = [
        'model/udp-header.h',

        internet_test.use.append('DL')

    if (bld.env['ENABLE_EXAMPLES']):
        bld.recurse('examples')

    bld.ns3_python_bindings()


(-)a/src/lte/wscript (-2 / +2 lines)

Lines 114-120	Link Here

114

        'test/lte-test-mimo.cc'

114

        'test/lte-test-mimo.cc'

115

116

117

    headers = bld.new_task_gen(features=['ns3header'])

117

    headers = bld(features='ns3header')

118

    headers.module = 'lte'

118

    headers.module = 'lte'

119

    headers.source = [

119

    headers.source = [

120

        'model/lte-common.h',

120

        'model/lte-common.h',

Lines 190-195	Link Here

190

191

192

    if (bld.env['ENABLE_EXAMPLES']):

192

    if (bld.env['ENABLE_EXAMPLES']):

193

      bld.add_subdirs('examples')

193

      bld.recurse('examples')

194

195

    bld.ns3_python_bindings()

195

    bld.ns3_python_bindings()

(-)a/src/mesh/wscript (-2 / +2 lines)

Lines 53-59	Link Here

        'test/flame/regression.cc',

        'test/flame/regression.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'mesh'

    headers.module = 'mesh'

    headers.source = [

    headers.source = [

        'model/mesh-information-element.h',

        'model/mesh-information-element.h',

Lines 90-95	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/mobility/wscript (-2 / +2 lines)

Lines 31-37	Link Here

        'test/waypoint-mobility-model-test.cc',

        'test/waypoint-mobility-model-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'mobility'

    headers.module = 'mobility'

    headers.source = [

    headers.source = [

        'model/box.h',

        'model/box.h',

Lines 55-60	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()




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

from waflib import Options
from waflib.Errors import WafError

def configure(conf):

        'model/mpi-receiver.cc',
        ]

    headers = bld(features='ns3header')
    headers.module = 'mpi'
    headers.source = [
        'model/distributed-simulator-impl.h',

        sim.use.append('MPI')

    if bld.env['ENABLE_EXAMPLES']:
        bld.recurse('examples')
      
    bld.ns3_python_bindings()

(-)a/src/netanim/wscript (-2 / +2 lines)

Lines 18-24	Link Here

        	'test/netanim-test.cc',

        	'test/netanim-test.cc',

	headers = bld.new_task_gen (features=['ns3header'])

	headers = bld(features='ns3header')

	headers.module = 'netanim'

	headers.module = 'netanim'

	headers.source = [

	headers.source = [

			  'model/animation-interface.h',

			  'model/animation-interface.h',

Lines 26-30	Link Here

	if (bld.env['ENABLE_EXAMPLES']) :

	if (bld.env['ENABLE_EXAMPLES']) :

		bld.add_subdirs ('examples')

		bld.recurse('examples')

(-)a/src/network/wscript (-2 / +2 lines)

Lines 71-77	Link Here

        'test/sequence-number-test-suite.cc',

        'test/sequence-number-test-suite.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'network'

    headers.module = 'network'

    headers.source = [

    headers.source = [

        'model/address.h',

        'model/address.h',

Lines 135-140	Link Here

135

136

137

    if (bld.env['ENABLE_EXAMPLES']):

137

    if (bld.env['ENABLE_EXAMPLES']):

138

        bld.add_subdirs('examples')

138

        bld.recurse('examples')

139

140

    bld.ns3_python_bindings()

140

    bld.ns3_python_bindings()

(-)a/src/nix-vector-routing/wscript (-2 / +2 lines)

Lines 8-14	Link Here

	'helper/ipv4-nix-vector-helper.cc',

	'helper/ipv4-nix-vector-helper.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'nix-vector-routing'

    headers.module = 'nix-vector-routing'

    headers.source = [

    headers.source = [

        'model/ipv4-nix-vector-routing.h',

        'model/ipv4-nix-vector-routing.h',

Lines 16-21	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/olsr/wscript (-2 / +2 lines)

Lines 20-26	Link Here

        'test/tc-regression-test.cc',

        'test/tc-regression-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'olsr'

    headers.module = 'olsr'

    headers.source = [

    headers.source = [

        'model/olsr-routing-protocol.h',

        'model/olsr-routing-protocol.h',

Lines 32-37	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()




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

import os
from waflib import Logs, Options
from waflib.Errors import WafError

def options(opt):
    opt.add_option('--with-openflow',
		   help=('Path to OFSID source for NS-3 OpenFlow Integration support'),
		   default='', dest='with_openflow')

REQUIRED_BOOST_LIBS = ['system', 'signals', 'filesystem']

def required_boost_libs(conf):
    conf.env.REQUIRED_BOOST_LIBS += REQUIRED_BOOST_LIBS

def configure(conf):
    if not conf.env.LIB_BOOST:
	conf.report_optional_feature("openflow", "NS-3 OpenFlow Integration", False,
				     "Required boost libraries not found")
        if not conf.env.LIB_BOOST:
            conf.check_boost(lib='signals filesystem', libpath="/usr/lib64")
    except WafError:
        conf.env['LIB_BOOST'] = []

        # Add this module to the list of modules that won't be built
        # if they are enabled.
        conf.env['MODULES_NOT_BUILT'].append('openflow')

	return 

    missing = [lib for lib in REQUIRED_BOOST_LIBS if lib not in conf.env.BOOST_FOUND_LIBS]
    if missing != []:
	conf.report_optional_feature("openflow", "NS-3 OpenFlow Integration", False,
				     "Required boost libraries not found")


	obj.use.extend('OPENFLOW DL XML2'.split())
	obj_test.use.extend('OPENFLOW DL XML2'.split())

    headers = bld(features='ns3header')
    headers.module = 'openflow'
    headers.source = [
        ]

	headers.source.append('helper/openflow-switch-helper.h')

    if bld.env['ENABLE_EXAMPLES'] and bld.env['ENABLE_OPENFLOW']:
        bld.recurse('examples')

(-)a/src/point-to-point-layout/wscript (-1 / +1 lines)

Lines 9-15	Link Here

        'model/point-to-point-star.cc',

        'model/point-to-point-star.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'point-to-point-layout'

    headers.module = 'point-to-point-layout'

    headers.source = [

    headers.source = [

        'model/point-to-point-dumbbell.h',

        'model/point-to-point-dumbbell.h',

(-)a/src/point-to-point/wscript (-2 / +2 lines)

Lines 16-22	Link Here

        'test/point-to-point-test.cc',

        'test/point-to-point-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'point-to-point'

    headers.module = 'point-to-point'

    headers.source = [

    headers.source = [

        'model/point-to-point-net-device.h',

        'model/point-to-point-net-device.h',

Lines 27-32	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/propagation/wscript (-2 / +2 lines)

Lines 24-30	Link Here

        'test/itu-r-1411-nlos-over-rooftop-test-suite.cc',

        'test/itu-r-1411-nlos-over-rooftop-test-suite.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'propagation'

    headers.module = 'propagation'

    headers.source = [

    headers.source = [

        'model/propagation-delay-model.h',

        'model/propagation-delay-model.h',

Lines 41-46	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/spectrum/wscript (-2 / +2 lines)

Lines 41-47	Link Here

        'test/spectrum-ideal-phy-test.cc',

        'test/spectrum-ideal-phy-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'spectrum'

    headers.module = 'spectrum'

    headers.source = [

    headers.source = [

        'model/spectrum-model.h',

        'model/spectrum-model.h',

Lines 76-82	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()




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

def configure(conf):
    have_sqlite3 = conf.check_cfg(package='sqlite3', uselib_store='SQLITE3',
                                  args=['--cflags', '--libs'],
                                  mandatory=False)
   conf.report_optional_feature("SqliteDataOutput", "SQlite stats data output",
                                conf.env['SQLITE_STATS'],
                                "library 'sqlite3' not found")

    conf.env['SQLITE_STATS'] = have_sqlite3
    conf.report_optional_feature("SqliteDataOutput", "SQlite stats data output",
                                 conf.env['SQLITE_STATS'],
                                 "library 'sqlite3' not found")

def build(bld):
    obj = bld.create_ns3_module('stats', ['network'])

        'test/basic-data-calculators-test-suite.cc',
        ]

    headers = bld(features='ns3header')
    headers.module = 'stats'
    headers.source = [
        'model/data-calculator.h',

(-)a/src/tap-bridge/wscript (-2 / +2 lines)

Lines 34-40	Link Here

        'model/tap-encode-decode.cc',

        'model/tap-encode-decode.cc',

        'helper/tap-bridge-helper.cc',

        'helper/tap-bridge-helper.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'tap-bridge'

    headers.module = 'tap-bridge'

    headers.source = [

    headers.source = [

        'model/tap-bridge.h',

        'model/tap-bridge.h',

Lines 52-57	Link Here

    module.env.append_value("DEFINES", "TAP_CREATOR=\"%s\"" % (tap_creator.target,))

    module.env.append_value("DEFINES", "TAP_CREATOR=\"%s\"" % (tap_creator.target,))

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/test/wscript (-1 / +1 lines)

Lines 16-22	Link Here

        return

        return

    test = bld.create_ns3_module('test', ['internet', 'mobility', 'applications', 'csma', 'bridge', 'config-store', 'tools', 'point-to-point', 'csma-layout', 'flow-monitor', 'wifi'])

    test = bld.create_ns3_module('test', ['internet', 'mobility', 'applications', 'csma', 'bridge', 'config-store', 'tools', 'point-to-point', 'csma-layout', 'flow-monitor', 'wifi'])

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'test'

    headers.module = 'test'

    test_test = bld.create_ns3_module_test_library('test')

    test_test = bld.create_ns3_module_test_library('test')

(-)a/src/tools/wscript (-2 / +2 lines)

Lines 15-21	Link Here

        'test/event-garbage-collector-test-suite.cc',

        'test/event-garbage-collector-test-suite.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'tools'

    headers.module = 'tools'

    headers.source = [

    headers.source = [

        'model/average.h',

        'model/average.h',

Lines 25-30	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/topology-read/wscript (-2 / +2 lines)

Lines 15-21	Link Here

        'test/rocketfuel-topology-reader-test-suite.cc',

        'test/rocketfuel-topology-reader-test-suite.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'topology-read'

    headers.module = 'topology-read'

    headers.source = [

    headers.source = [

       'model/topology-reader.h',

       'model/topology-reader.h',

Lines 26-31	Link Here

    if bld.env['ENABLE_EXAMPLES']:

    if bld.env['ENABLE_EXAMPLES']:

        bld.add_subdirs('examples')

        bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()

(-)a/src/uan/wscript (-2 / +2 lines)

Lines 34-40	Link Here

        'test/uan-test.cc',

        'test/uan-test.cc',

        'test/uan-energy-model-test.cc',

        'test/uan-energy-model-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'uan'

    headers.module = 'uan'

    headers.source = [

    headers.source = [

        'model/uan-channel.h',

        'model/uan-channel.h',

Lines 64-69	Link Here

    if (bld.env['ENABLE_EXAMPLES']):

    if (bld.env['ENABLE_EXAMPLES']):

      bld.add_subdirs('examples')

      bld.recurse('examples')

    bld.ns3_python_bindings()

    bld.ns3_python_bindings()




    module.source = [
        'model/virtual-net-device.cc',
        ]
    headers = bld(features='ns3header')
    headers.module = 'virtual-net-device'
    headers.source = [
        'model/virtual-net-device.h',
        ]

    if bld.env['ENABLE_EXAMPLES']:
        bld.recurse('examples')

    bld.ns3_python_bindings()

(-)a/src/visualizer/wscript (-3 / +3 lines)

Lines 1-5	Link Here

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

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

import Options

from waflib import Options

required_python_modules = [

required_python_modules = [

    'gtk',

    'gtk',

Lines 38-44	Link Here

def build(bld):

def build(bld):

    module = bld.create_ns3_module('visualizer', ['internet', 'wifi', 'point-to-point'])

    module = bld.create_ns3_module('visualizer', ['internet', 'wifi', 'point-to-point'])

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'visualizer'

    headers.module = 'visualizer'

    # Don't do anything more for this module if Python was explicitly

    # Don't do anything more for this module if Python was explicitly

Lines 61-67	Link Here

        'model/dummy-file-for-static-builds.cc',

        'model/dummy-file-for-static-builds.cc',

    module.features.append('pyembed')

    module.features += ' pyembed'

    #module.env.append_value('CXXFLAGS', module.env['shlib_CXXFLAGS'])

    #module.env.append_value('CXXFLAGS', module.env['shlib_CXXFLAGS'])

    #module.includes = '.'

    #module.includes = '.'

(-)a/src/wifi/wscript (-2 / +2 lines)

Lines 75-81	Link Here

        'test/wifi-test.cc',

        'test/wifi-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'wifi'

    headers.module = 'wifi'

    headers.source = [

    headers.source = [

        'model/wifi-information-element.h',

        'model/wifi-information-element.h',

Lines 144-150	Link Here

144

        obj_test.use.extend(['GSL', 'GSLCBLAS', 'M'])

144

        obj_test.use.extend(['GSL', 'GSLCBLAS', 'M'])

145

146

    if (bld.env['ENABLE_EXAMPLES']):

146

    if (bld.env['ENABLE_EXAMPLES']):

147

        bld.add_subdirs('examples')

147

        bld.recurse('examples')

148

149

    bld.ns3_python_bindings()

149

    bld.ns3_python_bindings()

150

(-)a/src/wimax/wscript (-2 / +2 lines)

Lines 63-69	Link Here

            'test/wimax-fragmentation-test.cc',

            'test/wimax-fragmentation-test.cc',

    headers = bld.new_task_gen(features=['ns3header'])

    headers = bld(features='ns3header')

    headers.module = 'wimax'

    headers.module = 'wimax'

    headers.source = [

    headers.source = [

            'model/wimax-channel.h',

            'model/wimax-channel.h',

Lines 113-118	Link Here

113

114

115

    if bld.env['ENABLE_EXAMPLES']:

115

    if bld.env['ENABLE_EXAMPLES']:

116

        bld.add_subdirs('examples')

116

        bld.recurse('examples')

117

118

    bld.ns3_python_bindings()

118

    bld.ns3_python_bindings()




import types
import warnings

from waflib import TaskGen, Task, Options, Build, Utils
from waflib.Errors import WafError

import TaskGen
import Task
import Options
import Build
import Utils

import wutils

try:

                   help=("Build only these modules (and dependencies)"),
                   dest='enable_modules')

    opt.load('boost', tooldir=['waf-tools'])

    for module in all_modules:
        opt.recurse(module, mandatory=False)


def configure(conf):
    conf.env.REQUIRED_BOOST_LIBS = []
    for module in all_modules:
        conf.recurse (module, name="required_boost_libs", mandatory=False)

    if conf.env.REQUIRED_BOOST_LIBS is not []:
        try:
            conf.load('boost')
            conf.check_boost(lib=' '.join (conf.env.REQUIRED_BOOST_LIBS), require_all=False)
            if not conf.env.LIB_BOOST:
                conf.check_boost(lib=' '.join (conf.env.REQUIRED_BOOST_LIBS), libpath="/usr/lib64", require_all=False)
        except WafError:
            conf.env['LIB_BOOST'] = []

    for module in all_modules:
        conf.recurse(module, mandatory=False)

    blddir = os.path.abspath(os.path.join(conf.bldnode.abspath(), conf.variant))
    conf.env.append_value('NS3_MODULE_PATH', blddir)

    static = bool(bld.env.ENABLE_STATIC_NS3)
    # Create a separate library for this module.
    if static:
        module = bld(features='cxx cxxstlib ns3module')
    else:
        module = bld(features='cxx cxxshlib ns3module')
    module.target = '%s/ns%s-%s%s' % (bld.srcnode.path_from(module.path), wutils.VERSION,
                                       name, bld.env.BUILD_SUFFIX)
    linkflags = []
    cxxflags = []

    module.use = ['ns3-' + dep for dep in dependencies]
    module.test = test
    module.is_ns3_module = True
    module.ns3_dir_location = bld.path.path_from(bld.srcnode)

    module.env.append_value("INCLUDES", '#')


def apply_incpaths_ns3testlib(self):
    if not self.source:
        return
    testdir = self.source[-1].parent.path_from(self.bld.srcnode)
    self.env.append_value("DEFINES", 'NS_TEST_SOURCEDIR="%s"' % (testdir,))



    # the module being tested.
    library_name = name + "-test"
    library = bld.create_ns3_module(library_name, [name], test=True)
    library.features += " ns3testlib"

    # Modify attributes for the test library that are different from a
    # normal module.

    bld.env.append_value('NS3_MODULES_WITH_TEST_LIBRARIES', [(library.module_name, library.name)])

    # Set the include path from the build directory to modules. 
    relative_path_from_build_to_here = bld.path.path_from(bld.bldnode)
    include_flag = '-I' + relative_path_from_build_to_here
    library.env.append_value('CXXFLAGS', include_flag)
    library.env.append_value('CCFLAGS',  include_flag)

    return library

def create_obj(bld, *args):
    warnings.warn("(in %s) Use bld(...) call now, instead of bld.create_obj(...)" % str(bld.path),
                  DeprecationWarning, stacklevel=2)
    return bld(*args)


def ns3_python_bindings(bld):


    #debug = ('PYBINDGEN_DEBUG' in os.environ)
    debug = True # XXX
    source = [bld.srcnode.find_resource('bindings/python/ns3modulegen-modular.py'),
              bld.path.find_resource("bindings/modulegen__%s.py" % apidefs)]

    modulegen_customizations = bindings_dir.find_resource("modulegen_customizations.py")
    if modulegen_customizations is not None:
        source.append(modulegen_customizations)

    modulegen_local = bld.path.find_resource("bindings/modulegen_local.py")
    # the local customization file may or not exist
    if modulegen_local is not None:
        source.append("bindings/modulegen_local.py")

    module_py_name = module.replace('-', '_')
    module_target_dir = bld.srcnode.find_dir("bindings/python/ns").path_from(bld.path)

    # if bindings/<module>.py exists, it becomes the module frontend, and the C extension befomes _<module>
    if bld.path.find_resource("bindings/%s.py" % (module_py_name,)) is not None:
        bld(features='copy',
            features='copy',
            source=("bindings/%s.py" % (module_py_name,)),
            target=('%s/%s.py' % (module_target_dir, module_py_name)))
        extension_name = '_%s' % (module_py_name,)

        if was_enabled:
            features.append(name)

    bindgen = bld(features='command', source=source, target=target, command=argv)
    bindgen.env['FEATURES'] = ','.join(features)
    bindgen.dep_vars = ['FEATURES', "GCC_RTTI_ABI_COMPLETE"]
    bindgen.before = 'cxx'

    bindgen.install_path = None

    # generate the extension module
    pymod = bld(features='cxx cxxshlib pyext')
    pymod.source = ['bindings/ns3module.cc']
    pymod.target = '%s/%s' % (module_target_dir, extension_name)
    pymod.name = 'ns3module_%s' % module

        if not_built in all_modules:
            all_modules.remove(not_built)

    bld.recurse(list(all_modules))

    for module in all_modules:
        modheader = bld(features='ns3moduleheader')
        modheader.module = module.split('/')[-1]

class ns3pcfile_task(Task.Task):
    after = 'cxx'

    def __str__(self):
        "string to display to the user"



class ns3header_task(Task.Task):
    before = 'cxx gen_ns3_module_header'
    color = 'BLUE'

    def __str__(self):



class gen_ns3_module_header_task(Task.Task):
    before = 'cxx'
    after = 'ns3header'
    color = 'BLUE'





#!/usr/bin/env python
# encoding: utf-8
#
# partially based on boost.py written by Gernot Vormayr
# written by Ruediger Sonderfeld <ruediger@c-plusplus.de>, 2008
# modified by Bjoern Michaelsen, 2008
# modified by Luca Fossati, 2008
# rewritten for waf 1.5.1, Thomas Nagy, 2008
# rewritten for waf 1.6.2, Sylvain Rouquette, 2011

'''

This is an extra tool, not bundled with the default waf binary.
To add the boost tool to the waf file:
$ ./waf-light --tools=compat15,boost
	or, if you have waf >= 1.6.2
$ ./waf update --files=boost

When using this tool, the wscript will look like:

	def options(opt):
		opt.load('compiler_cxx boost')

	def configure(conf):
		conf.load('compiler_cxx boost')
		conf.check_boost(lib='system filesystem')

	def build(bld):
		bld(source='main.cpp', target='app', use='BOOST')

Options are generated, in order to specify the location of boost includes/libraries.
The `check_boost` configuration function allows to specify the used boost libraries.
It can also provide default arguments to the --boost-static and --boost-mt command-line arguments.
Everything will be packaged together in a BOOST component that you can use.

When using MSVC, a lot of compilation flags need to match your BOOST build configuration:
 - you may have to add /EHsc to your CXXFLAGS or define boost::throw_exception if BOOST_NO_EXCEPTIONS is defined.
   Errors: C4530
 - boost libraries will try to be smart and use the (pretty but often not useful) auto-linking feature of MSVC
   So before calling `conf.check_boost` you might want to disabling by adding:
   	conf.env.DEFINES_BOOST += ['BOOST_ALL_NO_LIB']
   Errors: 
 - boost might also be compiled with /MT, which links the runtime statically.
   If you have problems with redefined symbols, 
		self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']
		self.env['CXXFLAGS_%s' % var] += ['/MD', '/EHsc']
Passing `--boost-linkage_autodetect` might help ensuring having a correct linkage in some basic cases.

'''

import sys
import re
from waflib import Utils, Logs, Errors
from waflib.Configure import conf

BOOST_LIBS = ['/usr/lib', '/usr/local/lib', '/opt/local/lib', '/sw/lib', '/lib']
BOOST_INCLUDES = ['/usr/include', '/usr/local/include', '/opt/local/include', '/sw/include']
BOOST_VERSION_FILE = 'boost/version.hpp'
BOOST_VERSION_CODE = '''
#include <iostream>
#include <boost/version.hpp>
int main() { std::cout << BOOST_LIB_VERSION << std::endl; }
'''

# toolsets from {boost_dir}/tools/build/v2/tools/common.jam
PLATFORM = Utils.unversioned_sys_platform()
detect_intel = lambda env: (PLATFORM == 'win32') and 'iw' or 'il'
detect_clang = lambda env: (PLATFORM == 'darwin') and 'clang-darwin' or 'clang'
detect_mingw = lambda env: (re.search('MinGW', env.CXX[0])) and 'mgw' or 'gcc'
BOOST_TOOLSETS = {
	'borland':  'bcb',
	'clang':	detect_clang,
	'como':	 'como',
	'cw':	   'cw',
	'darwin':   'xgcc',
	'edg':	  'edg',
	'g++':	  detect_mingw,
	'gcc':	  detect_mingw,
	'icpc':	 detect_intel,
	'intel':	detect_intel,
	'kcc':	  'kcc',
	'kylix':	'bck',
	'mipspro':  'mp',
	'mingw':	'mgw',
	'msvc':	 'vc',
	'qcc':	  'qcc',
	'sun':	  'sw',
	'sunc++':   'sw',
	'tru64cxx': 'tru',
	'vacpp':	'xlc'
}


def options(opt):
	opt.add_option('--boost-includes', type='string',
				   default='', dest='boost_includes',
				   help='''path to the boost includes root (~boost root)
				   e.g. /path/to/boost_1_47_0''')
	opt.add_option('--boost-libs', type='string',
				   default='', dest='boost_libs',
				   help='''path to the directory where the boost libs are
				   e.g. /path/to/boost_1_47_0/stage/lib''')
	opt.add_option('--boost-static', action='store_true',
				   default=False, dest='boost_static',
				   help='link with static boost libraries (.lib/.a)')
	opt.add_option('--boost-mt', action='store_true',
				   default=False, dest='boost_mt',
				   help='select multi-threaded libraries')
	opt.add_option('--boost-abi', type='string', default='', dest='boost_abi',
				   help='''select libraries with tags (dgsyp, d for debug),
				   see doc Boost, Getting Started, chapter 6.1''')
	opt.add_option('--boost-linkage_autodetect', action="store_true", dest='boost_linkage_autodetect',
				   help="auto-detect boost linkage options (don't get used to it / might break other stuff)")
	opt.add_option('--boost-toolset', type='string',
				   default='', dest='boost_toolset',
				   help='force a toolset e.g. msvc, vc90, \
						gcc, mingw, mgw45 (default: auto)')
	py_version = '%d%d' % (sys.version_info[0], sys.version_info[1])
	opt.add_option('--boost-python', type='string',
				   default=py_version, dest='boost_python',
				   help='select the lib python with this version \
						(default: %s)' % py_version)


@conf
def __boost_get_version_file(self, dir):
	try:
		return self.root.find_dir(dir).find_node(BOOST_VERSION_FILE)
	except:
		return None


@conf
def boost_get_version(self, dir):
	"""silently retrieve the boost version number"""
	re_but = re.compile('^#define\\s+BOOST_LIB_VERSION\\s+"(.*)"$', re.M)
	try:
		val = re_but.search(self.__boost_get_version_file(dir).read()).group(1)
	except:
		val = self.check_cxx(fragment=BOOST_VERSION_CODE, includes=[dir], execute=False, define_ret=True)
	return val


@conf
def boost_get_includes(self, *k, **kw):
	includes = k and k[0] or kw.get('includes', None)
	if includes and self.__boost_get_version_file(includes):
		return includes
	for dir in BOOST_INCLUDES:
		if self.__boost_get_version_file(dir):
			return dir
	if includes:
		self.fatal('headers not found in %s' % includes)
	else:
		self.fatal('headers not found, please provide a --boost-includes argument (see help)')


@conf
def boost_get_toolset(self, cc):
	toolset = cc
	if not cc:
		build_platform = Utils.unversioned_sys_platform()
		if build_platform in BOOST_TOOLSETS:
			cc = build_platform
		else:
			cc = self.env.CXX_NAME
	if cc in BOOST_TOOLSETS:
		toolset = BOOST_TOOLSETS[cc]
	return isinstance(toolset, str) and toolset or toolset(self.env)


@conf
def __boost_get_libs_path(self, *k, **kw):
	''' return the lib path and all the files in it '''
	if 'files' in kw:
		return self.root.find_dir('.'), Utils.to_list(kw['files'])
	libs = k and k[0] or kw.get('libs', None)
	if libs:
		path = self.root.find_dir(libs)
		files = path.ant_glob('*boost_*')
	if not libs or not files:
		for dir in BOOST_LIBS:
			try:
				path = self.root.find_dir(dir)
				files = path.ant_glob('*boost_*')
				if files:
					break
				path = self.root.find_dir(dir + '64')
				files = path.ant_glob('*boost_*')
				if files:
					break
			except:
				path = None
	if not path:
		if libs:
			self.fatal('libs not found in %s' % libs)
		else:
			self.fatal('libs not found, please provide a --boost-libs argument (see help)')

	self.to_log('Found the boost path in %r with the libraries:' % path)
	for x in files:
		self.to_log('    %r' % x)
	return path, files

@conf
def boost_get_libs(self, *k, **kw):
	'''
	return the lib path and the required libs
	according to the parameters
	'''
	path, files = self.__boost_get_libs_path(**kw)
	t = []
	if kw.get('mt', False):
		t.append('mt')
	if kw.get('abi', None):
		t.append(kw['abi'])
	tags = t and '(-%s)+' % '-'.join(t) or ''
	toolset = self.boost_get_toolset(kw.get('toolset', ''))
	toolset_pat = '(-%s[0-9]{0,3})+' % toolset
	version = '(-%s)+' % self.env.BOOST_VERSION

	def find_lib(re_lib, files):
		for file in files:
			if re_lib.search(file.name):
				self.to_log('Found boost lib %s' % file)
				return file
		return None

	def format_lib_name(name):
		if name.startswith('lib') and self.env.CC_NAME != 'msvc':
			name = name[3:]
		return name[:name.rfind('.')]

        found_libs = []
	libs = []
	for lib in Utils.to_list(k and k[0] or kw.get('lib', None)):
		py = (lib == 'python') and '(-py%s)+' % kw['python'] or ''
		# Trying libraries, from most strict match to least one
		for pattern in ['boost_%s%s%s%s%s' % (lib, toolset_pat, tags, py, version),
						'boost_%s%s%s%s' % (lib, tags, py, version),
						'boost_%s%s%s' % (lib, tags, version),
						# Give up trying to find the right version
						'boost_%s%s%s%s' % (lib, toolset_pat, tags, py),
						'boost_%s%s%s' % (lib, tags, py),
						'boost_%s%s' % (lib, tags)]:
			self.to_log('Trying pattern %s' % pattern)
			file = find_lib(re.compile(pattern), files)
			if file:
                                found_libs.append (lib)
				libs.append(format_lib_name(file.name))
				break
		else:
                        # Don't fail, but just ignore failed library
                        Logs.error ('lib %s not found in %s' % (lib, path.abspath()))

	return path.abspath(), libs, found_libs


@conf
def check_boost(self, *k, **kw):
	"""
	Initialize boost libraries to be used.

	Keywords: you can pass the same parameters as with the command line (without "--boost-").
	Note that the command line has the priority, and should preferably be used.
	"""
	if not self.env['CXX']:
		self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')

	params = {'lib': k and k[0] or kw.get('lib', None)}
	for key, value in self.options.__dict__.items():
		if not key.startswith('boost_'):
			continue
		key = key[len('boost_'):]
		params[key] = value and value or kw.get(key, '')

	var = kw.get('uselib_store', 'BOOST')

	self.start_msg('Checking boost includes')
	self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
	self.env.BOOST_VERSION = self.boost_get_version(inc)
	self.end_msg(self.env.BOOST_VERSION)
	if Logs.verbose:
		Logs.pprint('CYAN', '	path : %s' % self.env['INCLUDES_%s' % var])

	if not params['lib']:
		return
	self.start_msg('Checking boost libs')
	suffix = params.get('static', None) and 'ST' or ''
	path, libs, found_libs = self.boost_get_libs(**params)
	self.env['%sLIBPATH_%s' % (suffix, var)] = [path]
	self.env['%sLIB_%s' % (suffix, var)] = libs
        self.env['%s_FOUND_LIBS' % var] = found_libs

        if kw.get('require_all', True):
                if found_libs != Utils.to_list(k and k[0] or kw.get('lib', None)):
                        required_libs = Utils.to_list(k and k[0] or kw.get('lib', None))
                        not_found = [lib for lib in required_libs if lib not in found_libs]
                        self.fatal('boost libraries %s not found' % (str(not_found)))

	self.end_msg('ok')
	if Logs.verbose:
		Logs.pprint('CYAN', '	path : %s' % path)
		Logs.pprint('CYAN', '	libs : %s' % libs)


	def try_link():
		if 'system' in params['lib']:
			self.check_cxx(
			 fragment="\n".join([
			  '#include <boost/system/error_code.hpp>',
			  'int main() { boost::system::error_code c; }',
			 ]),
			 use=var,
			 execute=False,
			)
		if 'thread' in params['lib']:
			self.check_cxx(
			 fragment="\n".join([
			  '#include <boost/thread.hpp>',
			  'int main() { boost::thread t; }',
			 ]),
			 use=var,
			 execute=False,
			)

	if params.get('linkage_autodetect', False):
		self.start_msg("Attempting to detect boost linkage flags")
		toolset = self.boost_get_toolset(kw.get('toolset', ''))
		if toolset in ['vc']:
			# disable auto-linking feature, causing error LNK1181
			# because the code wants to be linked against
			self.env['DEFINES_%s' % var] += ['BOOST_ALL_NO_LIB']

			# if no dlls are present, we guess the .lib files are not stubs
			has_dlls = False
			for x in Utils.listdir(path):
				if x.endswith(self.env.cxxshlib_PATTERN % ''):
					has_dlls = True
					break
			if not has_dlls:
				self.env['STLIBPATH_%s' % var] = [path]
				self.env['STLIB_%s' % var] = libs
				del self.env['LIB_%s' % var]
				del self.env['LIBPATH_%s' % var]

			# we attempt to play with some known-to-work CXXFLAGS combinations
			for cxxflags in (['/MD', '/EHsc'], []):
				self.env.stash()
				self.env["CXXFLAGS_%s" % var] += cxxflags
				try:
					try_link()
					self.end_msg("ok: winning cxxflags combination: %s" % (self.env["CXXFLAGS_%s" % var]))
					e = None
					break
				except Errors.ConfigurationError as exc:
					self.env.revert()
					e = exc

			if e is not None:
				self.fatal("Could not auto-detect boost linking flags combination, you may report it to boost.py author", ex=e)
		else:
			self.fatal("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
	else:
		self.start_msg('Checking for boost linkage')
		try:
			try_link()
		except Errors.ConfigurationError as e:
			self.fatal("Could not link against boost libraries using supplied options")
		self.end_msg('ok')


(-)a/waf-tools/cflags.py (-3 / +1 lines)

Lines 1-6	Link Here

import Logs

from waflib import Logs, Options, Utils

import Options

import Utils

class CompilerTraits(object):

class CompilerTraits(object):




import re
import Node, Task, Utils, Build
import subprocess

# import feature, taskgen_method, before_method, task_gen
from waflib import TaskGen, Node, Task, Utils, Build, Options, Logs, Task
debug = Logs.debug
error = Logs.error

import shellcmd
#shellcmd.subprocess = pproc # the WAF version of the subprocess module is supposedly less buggy

from Logs import debug, error
shellcmd.debug = debug

import Task

import re


arg_rx = re.compile(r"(?P<dollar>\$\$)|(?P<subst>\$\{(?P<var>\w+)(?P<code>.*?)\})", re.M)


(-)a/waf-tools/misc.py (-3 lines)

Lines 322-330	Link Here

322

323

	if self.cwd is None:

323

	if self.cwd is None:

324

		cwd = None

324

		cwd = None

325

	else:

326

		assert isinstance(cwd, CmdDirArg)

327

		self.cwd.find_node(self.path)

328

325

329

	args = []

326

	args = []

330

	inputs = []

327

	inputs = []




# -*- mode: python; encoding: utf-8 -*-
# Gustavo Carneiro (gjamc) 2008

import Options
import Configure
import subprocess
import config_c
import sys

def configure(conf):
	pkg_config = conf.find_program('pkg-config', var='PKG_CONFIG')
	if not pkg_config: return

@Configure.conf
def pkg_check_modules(conf, uselib_name, expression, mandatory=True):
	pkg_config = conf.env['PKG_CONFIG']
	if not pkg_config:
		if mandatory:
			conf.fatal("pkg-config is not available")
		else:
			return False

	if Options.options.verbose:
		extra_msg = ' (%s)' % expression
	else:
		extra_msg = ''

	conf.start_msg('Checking for pkg-config flags for %s%s' % (uselib_name, extra_msg))

	argv = [pkg_config, '--cflags', '--libs', expression]
	cmd = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
	out, err = cmd.communicate()
	retval = cmd.wait()

	conf.to_log('%r: %r (exit code %i)\n%s' % (argv, out, retval, err))

	if retval != 0:
		conf.end_msg(False)
		sys.stderr.write(err)
	else:
		if Options.options.verbose:
			conf.end_msg(out)
		else:
			conf.end_msg(True)

	if retval == 0:
		conf.parse_flags(out, uselib_name, conf.env)
		conf.env[uselib_name] = True
		return True

	else:

		conf.env[uselib_name] = False
		if mandatory:
			raise Configure.ConfigurationError('pkg-config check failed')
		else:
			return False

@Configure.conf
def pkg_check_module_variable(conf, module, variable):
	pkg_config = conf.env['PKG_CONFIG']
	if not pkg_config:
		conf.fatal("pkg-config is not available")

	argv = [pkg_config, '--variable', variable, module]
	cmd = subprocess.Popen(argv, stdout=subprocess.PIPE)
	out, dummy = cmd.communicate()
	retval = cmd.wait()
	out = out.rstrip() # strip the trailing newline

	msg_checking = ("Checking for pkg-config variable %r in %s" % (variable, module,))
	conf.check_message_custom(msg_checking, '', out)
	conf.log.write('%r: %r (exit code %i)\n' % (argv, out, retval))

	if retval == 0:
		return out
	else:
		raise Configure.ConfigurationError('pkg-config check failed')

(-)a/waf-tools/relocation.py (-2 / +2 lines)

Lines 64-70	Link Here

	try:

	try:

		return self.uid_

		return self.uid_

	except AttributeError:

	except AttributeError:

		# this is not a real hot zone, but we want to avoid surprizes here

		# this is not a real hot zone, but we want to avoid surprises here

		m = Utils.md5()

		m = Utils.md5()

		up = m.update

		up = m.update

		up(self.__class__.__name__.encode())

		up(self.__class__.__name__.encode())

Lines 80-85	Link Here

	lst = self.to_incnodes(self.to_list(getattr(self, 'includes', [])) + self.env['INCLUDES'])

	lst = self.to_incnodes(self.to_list(getattr(self, 'includes', [])) + self.env['INCLUDES'])

	self.includes_nodes = lst

	self.includes_nodes = lst

	bld = self.bld

	bld = self.bld

	self.env['INCPATHS'] = [x.is_child_of(bld.srcnode) and x.path_from(bld.srcnode) or x.abspath() for x in lst]

	self.env['INCPATHS'] = [x.is_child_of(bld.srcnode) and x.path_from(bld.bldnode) or x.abspath() for x in lst]




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
import Options

import Logs
import TaskGen

import Task

import Utils
import Build
import Configure
import Scripting

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.

	}
cflags.default_profile = 'debug'

# local modules
import wutils

Configure.autoconfig = 0

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

                   dest='doxygen_no_build')

    # options provided in subdirectories
    opt.recurse('src')
    opt.recurse('bindings/python')
    opt.recurse('src/internet')


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

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

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

    if mode == 'cc':
        mode = 'c'

        retval = conf.run_c_code(code='#include <stdio.h>\nint main() { return 0; }\n',
                                 env=env, compile_filename=fname,
                                 features=[mode, mode+'program'], execute=False)
    except Errors.ConfigurationError:
        ok = False
    else:
        ok = (retval == 0)

        return None

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

    # attach some extra methods
    conf.check_nonfatal = types.MethodType(_check_nonfatal, conf)

    conf.check_optional_feature = types.MethodType(check_optional_feature, conf)
    conf.env['NS3_OPTIONAL_FEATURES'] = []

    conf.load('compiler_c')
    conf.load('compiler_cxx')
    conf.load('cflags', tooldir=['waf-tools'])
    conf.load('command', tooldir=['waf-tools'])
    conf.load('gnu_dirs')
    except Configure.ConfigurationError:
        pass
    conf.check_tool('command', ['waf-tools'])
    conf.check_tool('gnu_dirs')

    env = conf.env



    conf.env['MODULES_NOT_BUILT'] = []

    conf.recurse('bindings/python')

    conf.recurse('src')

    # Set the list of enabled modules.
    if Options.options.enable_modules:

            if not conf.env['NS3_ENABLED_MODULES']:
                raise WafError('Exiting because the ' + not_built + ' module can not be built and it was the only one enabled.')

    conf.recurse('src/mpi')

    # for suid bits
    try:

    # These flags are used for the implicitly dependent modules.
    if env['ENABLE_STATIC_NS3']:
        if sys.platform == 'darwin':
            env.STLIB_MARKER = '-Wl,-all_load'
        else:
            env.STLIB_MARKER = '-Wl,--whole-archive,-Bstatic'
            env.SHLIB_MARKER = '-Wl,-Bdynamic,--no-whole-archive'


    have_gsl = conf.check_cfg(package='gsl', args=['--cflags', '--libs'],
                              uselib_store='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('DEFINES', "ENABLE_GSL")

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

        except ValueError, ex:
            raise WafError(str(ex))
        program_node = program_obj.path.find_or_declare(program_obj.target)
        self.filename = program_node.get_bld().abspath()


    def run(self):

def create_suid_program(bld, name):
    grp = bld.current_group
    bld.add_group() # this to make sure no two sudo tasks run at the same time
    program = bld(features='cxx cxxprogram')
    program.is_ns3_program = True
    program.module_deps = list()
    program.name = name

    return program

def create_ns3_program(bld, name, dependencies=('core',)):
    program = bld(features='cxx cxxprogram')

    program.is_ns3_program = True
    program.name = name

        if sys.platform == 'darwin':
            program.env.STLIB_MARKER = '-Wl,-all_load'
        else:
            program.env.STLIB_MARKER = '-Wl,-Bstatic,--whole-archive'
            program.env.SHLIB_MARKER = '-Wl,-Bdynamic,--no-whole-archive'
    else:
        if program.env.DEST_BINFMT == 'elf':

            if dir.startswith('.') or dir == 'CVS':
                continue
            if os.path.isdir(os.path.join('examples', dir)):
                bld.recurse(os.path.join('examples', dir))


def add_scratch_programs(bld):
    all_modules = [mod[len("ns3-"):] for mod in bld.env['NS3_ENABLED_MODULES']]

            obj.name = obj.target
            obj.install_path = None


def _get_all_task_gen(self):
    for group in self.groups:
        for taskgen in group:


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

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

    bld.find_ns3_module = types.MethodType(_find_ns3_module, bld)

    # process subfolders from here
    bld.recurse('src')

    # If modules have been enabled, then set lists of enabled modules
    # and enabled module test libraries.

                    # launch directory.
                    launch_dir = os.path.abspath(Context.launch_dir)
                    object_relative_path = os.path.join(
                        wutils.relpath(obj.path.get_bld().abspath(), launch_dir),
                        object_name)

                    bld.env.append_value('NS3_RUNNABLE_PROGRAMS', object_relative_path)

        if script_runnable:
            bld.env.append_value('NS3_RUNNABLE_SCRIPTS', script)

    bld.recurse('bindings/python')

    # Process this subfolder here after the lists of enabled modules
    # and module test libraries have been set.
    bld.recurse('utils')

    # Set this so that the lists will be printed at the end of this
    # build command.




from waflib import Context, Build
class CheckContext(Context.Context):
    """run the equivalent of the old ns-3 unit tests using test.py"""
    cmd = 'check'



class print_introspected_doxygen_task(Task.TaskBase):
    after = 'cxx link'
    color = 'BLUE'

    def __init__(self, bld):

                           # --enable-modules=xxx
            pass
        else:
            prog = program_obj.path.find_or_declare(ccroot.get_target_name(program_obj)).get_bld().abspath(env)

            # Create a header file with the introspected information.
            doxygen_out = open(os.path.join('doc', 'introspected-doxygen.h'), 'w')

            text_out.close()

class run_python_unit_tests_task(Task.TaskBase):
    after = 'cxx link'
    color = 'BLUE'

    def __init__(self, bld):

        raise WafError(msg)


from waflib import Context, Build
class Ns3ShellContext(Context.Context):
    """run a shell with an environment suitably modified to run locally built programs"""
    cmd = 'shell'

        raise SystemExit(1)
        return

    prog = program_obj.path.find_or_declare(program_obj.target).get_bld().abspath()

    if not os.path.exists(prog):
        Logs.error("print-introspected-doxygen has not been built yet."

        raise SystemExit(1)


from waflib import Context, Build

def _getVersion():
    """update the ns3_version.js file, when building documentation"""


	bld.execute()
        _doxygen(bld)

from waflib import Context, Build
class Ns3SphinxContext(Context.Context):
    """build the Sphinx documentation: manual, tutorial, models"""
    

            self.sphinx_build(os.path.join("doc", sphinxdir))
     

from waflib import Context, Build
class Ns3DocContext(Context.Context):
    """build all the documentation: doxygen, manual, tutorial, models"""
    




import os
import os.path
import re
import sys
import subprocess
import shlex

# WAF modules
from waflib import Options, Utils, Logs, TaskGen, Build, Context
import Utils
import Logs
import TaskGen
import Build
import re
from waflib.Errors import WafError

# these are set from the main wscript file

            return os.path.curdir
        return os.path.join(*rel_list)


def find_program(program_name, env):
    launch_dir = os.path.abspath(Context.launch_dir)
    #top_dir = os.path.abspath(Options.cwd_launch)

Return to bug 1562