253 lines
8.6 KiB
Python
253 lines
8.6 KiB
Python
## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
|
|
|
|
import os, os.path
|
|
import shutil
|
|
import types
|
|
import warnings
|
|
|
|
import TaskGen
|
|
import Task
|
|
import Options
|
|
import Build
|
|
import Utils
|
|
|
|
all_modules = (
|
|
'core',
|
|
'common',
|
|
'simulator',
|
|
'contrib',
|
|
'node',
|
|
'internet-stack',
|
|
'devices/point-to-point',
|
|
'devices/csma',
|
|
'devices/emu',
|
|
'devices/bridge',
|
|
'devices/tap-bridge',
|
|
'devices/virtual-net-device',
|
|
'applications/onoff',
|
|
'applications/packet-sink',
|
|
'applications/udp-echo',
|
|
'routing/nix-vector-routing',
|
|
'routing/olsr',
|
|
'routing/global-routing',
|
|
'routing/static-routing',
|
|
'routing/list-routing',
|
|
'routing/aodv',
|
|
'mobility',
|
|
'devices/wifi',
|
|
'helper',
|
|
'contrib/stats',
|
|
'applications/v4ping',
|
|
'devices/mesh',
|
|
'devices/mesh/dot11s',
|
|
'devices/mesh/flame',
|
|
'applications/ping6',
|
|
'applications/radvd',
|
|
'test',
|
|
'test/ns3tcp',
|
|
'test/ns3wifi',
|
|
'contrib/flow-monitor',
|
|
'contrib/net-anim',
|
|
)
|
|
|
|
def set_options(opt):
|
|
opt.sub_options('simulator')
|
|
|
|
opt.add_option('--enable-rpath',
|
|
help=("Link programs with rpath"
|
|
" (normally not needed, see "
|
|
" --run and --shell; moreover, only works in some"
|
|
" specific platforms, such as Linux and Solaris)"),
|
|
action="store_true", dest='enable_rpath', default=False)
|
|
|
|
opt.add_option('--enable-modules',
|
|
help=("Build only these modules (and dependencies)"),
|
|
dest='enable_modules')
|
|
|
|
def configure(conf):
|
|
conf.sub_config('core')
|
|
conf.sub_config('simulator')
|
|
conf.sub_config('devices/emu')
|
|
conf.sub_config('devices/tap-bridge')
|
|
conf.sub_config('contrib')
|
|
conf.sub_config('internet-stack')
|
|
|
|
blddir = os.path.abspath(os.path.join(conf.blddir, conf.env.variant()))
|
|
conf.env.append_value('NS3_MODULE_PATH', blddir)
|
|
if Options.options.enable_rpath:
|
|
conf.env.append_value('RPATH', '-Wl,-rpath=%s' % (os.path.join(blddir),))
|
|
|
|
## Used to link the 'test-runner' program with all of ns-3 code
|
|
conf.env['NS3_MODULES'] = ['ns3-' + module.split('/')[-1] for module in all_modules]
|
|
|
|
|
|
def create_ns3_module(bld, name, dependencies=()):
|
|
module = bld.new_task_gen('cxx')
|
|
module.name = 'ns3-' + name
|
|
module.target = module.name
|
|
module.add_objects = ['ns3-' + dep for dep in dependencies]
|
|
module.module_deps = list(dependencies)
|
|
if not module.env['ENABLE_STATIC_NS3']:
|
|
module.env.append_value('CXXFLAGS', module.env['shlib_CXXFLAGS'])
|
|
elif module.env['CXX_NAME'] in ['gcc', 'icc'] and \
|
|
os.uname()[4] == 'x86_64' and \
|
|
module.env['ENABLE_PYTHON_BINDINGS']:
|
|
# enable that flag for static builds only on x86-64 platforms
|
|
# when gcc is present and only when we want python bindings
|
|
# (it's more efficient to not use this option if we can avoid it)
|
|
module.env.append_value('CXXFLAGS', '-mcmodel=large')
|
|
|
|
module.env.append_value('CXXDEFINES', "NS3_MODULE_COMPILATION")
|
|
return module
|
|
|
|
def create_obj(bld, *args):
|
|
warnings.warn("(in %s) Use bld.new_task_gen(...) now, instead of bld.create_obj(...)" % str(bld.path),
|
|
DeprecationWarning, stacklevel=2)
|
|
return bld.new_task_gen(*args)
|
|
|
|
def build(bld):
|
|
bld.create_ns3_module = types.MethodType(create_ns3_module, bld)
|
|
bld.create_obj = types.MethodType(create_obj, bld)
|
|
|
|
bld.add_subdirs(list(all_modules))
|
|
|
|
for module in all_modules:
|
|
modheader = bld.new_task_gen('ns3moduleheader')
|
|
modheader.module = module.split('/')[-1]
|
|
|
|
|
|
class ns3header_taskgen(TaskGen.task_gen):
|
|
"""A set of NS-3 header files"""
|
|
COLOR = 'BLUE'
|
|
def __init__(self, *args, **kwargs):
|
|
super(ns3header_taskgen, self).__init__(*args, **kwargs)
|
|
self.install_path = None
|
|
self.sub_dir = None # if not None, header files will be published as ns3/sub_dir/file.h
|
|
self.module = None # module name
|
|
|
|
def apply(self):
|
|
if self.module is None:
|
|
raise Utils.WafError("'module' missing on ns3headers object %s" % self)
|
|
ns3_dir_node = self.bld.path.find_dir("ns3")
|
|
if self.sub_dir is not None:
|
|
ns3_dir_node = ns3_dir_node.find_dir(self.sub_dir)
|
|
for filename in self.to_list(self.source):
|
|
src_node = self.path.find_resource(filename)
|
|
if src_node is None:
|
|
raise Utils.WafError("source ns3 header file %s not found" % (filename,))
|
|
dst_node = ns3_dir_node.find_or_declare(os.path.basename(filename))
|
|
assert dst_node is not None
|
|
task = self.create_task('ns3header', self.env)
|
|
task.set_inputs([src_node])
|
|
task.set_outputs([dst_node])
|
|
|
|
class ns3header_task(Task.Task):
|
|
before = 'cc cxx gen_ns3_module_header_task'
|
|
color = 'BLUE'
|
|
def run(self):
|
|
assert len(self.inputs) == len(self.outputs)
|
|
inputs = [node.srcpath(self.env) for node in self.inputs]
|
|
outputs = [node.bldpath(self.env) for node in self.outputs]
|
|
for src, dst in zip(inputs, outputs):
|
|
try:
|
|
os.chmod(dst, 0600)
|
|
except OSError:
|
|
pass
|
|
shutil.copy2(src, dst)
|
|
## make the headers in builddir read-only, to prevent
|
|
## accidental modification
|
|
os.chmod(dst, 0400)
|
|
return 0
|
|
|
|
|
|
|
|
class gen_ns3_module_header_task(Task.Task):
|
|
before = 'cc cxx'
|
|
after = 'ns3header_task'
|
|
color = 'BLUE'
|
|
def run(self):
|
|
assert len(self.outputs) == 1
|
|
header_files = [os.path.basename(node.abspath(self.env)) for node in self.inputs]
|
|
outfile = file(self.outputs[0].bldpath(self.env), "w")
|
|
header_files.sort()
|
|
|
|
print >> outfile, """
|
|
#ifdef NS3_MODULE_COMPILATION
|
|
# error "Do not include ns3 module aggregator headers from other modules; these are meant only for end user scripts."
|
|
#endif
|
|
|
|
#ifndef NS3_MODULE_%s
|
|
""" % (self.module.upper().replace('-', '_'),)
|
|
|
|
# if self.module_deps:
|
|
# print >> outfile, "// Module dependencies:"
|
|
# for dep in self.module_deps:
|
|
# print >> outfile, "#include \"%s-module.h\"" % dep
|
|
|
|
print >> outfile
|
|
print >> outfile, "// Module headers:"
|
|
for header in header_files:
|
|
print >> outfile, "#include \"%s\"" % (header,)
|
|
|
|
print >> outfile, "#endif"
|
|
|
|
outfile.close()
|
|
return 0
|
|
|
|
def sig_explicit_deps(self):
|
|
m = Utils.md5()
|
|
m.update('\n'.join([node.abspath(self.env) for node in self.inputs]))
|
|
return m.digest()
|
|
|
|
def unique_id(self):
|
|
try:
|
|
return self.uid
|
|
except AttributeError:
|
|
"this is not a real hot zone, but we want to avoid surprizes here"
|
|
m = Utils.md5()
|
|
m.update("ns-3-module-header-%s" % self.module)
|
|
self.uid = m.digest()
|
|
return self.uid
|
|
|
|
|
|
class ns3moduleheader_taskgen(TaskGen.task_gen):
|
|
"""
|
|
Generates a 'ns3/foo-module.h' header file that includes all
|
|
public ns3 headers of a certain module.
|
|
"""
|
|
COLOR = 'BLUE'
|
|
def __init__(self, *args, **kwargs):
|
|
super(ns3moduleheader_taskgen, self).__init__(*args, **kwargs)
|
|
|
|
def apply(self):
|
|
## get all of the ns3 headers
|
|
ns3_dir_node = self.bld.path.find_dir("ns3")
|
|
all_headers_inputs = []
|
|
found_the_module = False
|
|
for ns3headers in self.bld.all_task_gen:
|
|
if isinstance(ns3headers, ns3header_taskgen):
|
|
if ns3headers.module != self.module:
|
|
continue
|
|
found_the_module = True
|
|
for source in ns3headers.to_list(ns3headers.source):
|
|
source = os.path.basename(source)
|
|
node = ns3_dir_node.find_or_declare(os.path.basename(source))
|
|
if node is None:
|
|
fatal("missing header file %s" % (source,))
|
|
all_headers_inputs.append(node)
|
|
if not found_the_module:
|
|
raise Utils.WscriptError("error finding headers for module %s" % self.module)
|
|
if not all_headers_inputs:
|
|
return
|
|
module_obj = self.bld.name_to_obj("ns3-" + self.module, self.env)
|
|
assert module_obj is not None
|
|
all_headers_outputs = [ns3_dir_node.find_or_declare("%s-module.h" % self.module)]
|
|
task = self.create_task('gen_ns3_module_header', self.env)
|
|
task.set_inputs(all_headers_inputs)
|
|
task.set_outputs(all_headers_outputs)
|
|
task.module = self.module
|
|
task.module_deps = module_obj.module_deps
|
|
|
|
def install(self):
|
|
pass
|