forked from tkn-tub/ns3-gym
-
Notifications
You must be signed in to change notification settings - Fork 0
/
wscript
1182 lines (976 loc) · 43.2 KB
/
wscript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
## -*- 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
import shlex
import subprocess
import textwrap
from utils import read_config_file
# WAF modules
from waflib import Utils, Scripting, Configure, Build, Options, TaskGen, Context, Task, Logs, Errors
from waflib.Errors import WafError
# local modules
import wutils
# By default, all modules will be enabled, examples will be disabled,
# and tests will be disabled.
modules_enabled = ['all_modules']
examples_enabled = False
tests_enabled = False
# Get the information out of the NS-3 configuration file.
config_file_exists = False
(config_file_exists, modules_enabled, examples_enabled, tests_enabled) = read_config_file()
sys.path.insert(0, os.path.abspath('waf-tools'))
try:
import cflags # override the build profiles from waf
finally:
sys.path.pop(0)
cflags.profiles = {
# profile name: [optimization_level, warnings_level, debug_level]
'debug': [0, 2, 3],
'optimized': [3, 2, 1],
'release': [3, 2, 0],
}
cflags.default_profile = 'debug'
Configure.autoconfig = 0
# the following two variables are used by the target "waf dist"
VERSION = file("VERSION", "rt").read().strip()
APPNAME = 'ns'
wutils.VERSION = VERSION
wutils.APPNAME = APPNAME
# we don't use VNUM anymore (see bug #1327 for details)
wutils.VNUM = None
# these variables are mandatory ('/' are converted automatically)
top = '.'
out = 'build'
def load_env():
bld_cls = getattr(Utils.g_module, 'build_context', Utils.Context)
bld_ctx = bld_cls()
bld_ctx.load_dirs(os.path.abspath(os.path.join (srcdir,'..')),
os.path.abspath(os.path.join (srcdir,'..', blddir)))
bld_ctx.load_envs()
env = bld_ctx.get_env()
return env
def get_files(base_dir):
retval = []
reference=os.path.dirname(base_dir)
for root, dirs, files in os.walk(base_dir):
if root.find('.hg') != -1:
continue
for file in files:
if file.find('.hg') != -1:
continue
fullname = os.path.join(root,file)
# we can't use os.path.relpath because it's new in python 2.6
relname = fullname.replace(reference + '/','')
retval.append([fullname,relname])
return retval
def dist_hook():
import tarfile
shutil.rmtree("doc/html", True)
shutil.rmtree("doc/latex", True)
shutil.rmtree("nsc", True)
# Print the sorted list of module names in columns.
def print_module_names(names):
# Sort the list of module names.
names.sort()
# Print the list of module names in 3 columns.
i = 1
for name in names:
print name.ljust(25),
if i == 3:
print
i = 0
i = i+1
if i != 1:
print
def options(opt):
# options provided by the modules
opt.load('compiler_c')
opt.load('compiler_cxx')
opt.load('cflags')
opt.load('gnu_dirs')
opt.add_option('--cwd',
help=('Set the working directory for a program.'),
action="store", type="string", default=None,
dest='cwd_launch')
opt.add_option('--enable-gcov',
help=('Enable code coverage analysis.'
' WARNING: this option only has effect '
'with the configure command.'),
action="store_true", default=False,
dest='enable_gcov')
opt.add_option('--no-task-lines',
help=("Don't print task lines, i.e. messages saying which tasks are being executed by WAF."
" Coupled with a single -v will cause WAF to output only the executed commands,"
" just like 'make' does by default."),
action="store_true", default=False,
dest='no_task_lines')
opt.add_option('--lcov-report',
help=('Generate a code coverage report '
'(use this option at build time, not in configure)'),
action="store_true", default=False,
dest='lcov_report')
opt.add_option('--run',
help=('Run a locally built program; argument can be a program name,'
' or a command starting with the program name.'),
type="string", default='', dest='run')
opt.add_option('--visualize',
help=('Modify --run arguments to enable the visualizer'),
action="store_true", default=False, dest='visualize')
opt.add_option('--command-template',
help=('Template of the command used to run the program given by --run;'
' It should be a shell command string containing %s inside,'
' which will be replaced by the actual program.'),
type="string", default=None, dest='command_template')
opt.add_option('--pyrun',
help=('Run a python program using locally built ns3 python module;'
' argument is the path to the python program, optionally followed'
' by command-line options that are passed to the program.'),
type="string", default='', dest='pyrun')
opt.add_option('--valgrind',
help=('Change the default command template to run programs and unit tests with valgrind'),
action="store_true", default=False,
dest='valgrind')
opt.add_option('--shell',
help=('DEPRECATED (run ./waf shell)'),
action="store_true", default=False,
dest='shell')
opt.add_option('--enable-sudo',
help=('Use sudo to setup suid bits on ns3 executables.'),
dest='enable_sudo', action='store_true',
default=False)
opt.add_option('--enable-tests',
help=('Build the ns-3 tests.'),
dest='enable_tests', action='store_true',
default=False)
opt.add_option('--disable-tests',
help=('Do not build the ns-3 tests.'),
dest='disable_tests', action='store_true',
default=False)
opt.add_option('--enable-examples',
help=('Build the ns-3 examples.'),
dest='enable_examples', action='store_true',
default=False)
opt.add_option('--disable-examples',
help=('Do not build the ns-3 examples.'),
dest='disable_examples', action='store_true',
default=False)
opt.add_option('--check',
help=('DEPRECATED (run ./test.py)'),
default=False, dest='check', action="store_true")
opt.add_option('--enable-static',
help=('Compile NS-3 statically: works only on linux, without python'),
dest='enable_static', action='store_true',
default=False)
opt.add_option('--enable-mpi',
help=('Compile NS-3 with MPI and distributed simulation support'),
dest='enable_mpi', action='store_true',
default=False)
opt.add_option('--doxygen-no-build',
help=('Run doxygen to generate html documentation from source comments, '
'but do not wait for ns-3 to finish the full build.'),
action="store_true", default=False,
dest='doxygen_no_build')
# 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):
"""
Checks if the C++ compiler accepts a certain compilation flag or flags
flag: can be a string or a list of strings
"""
l = []
if flag:
l.append(flag)
if isinstance(linkflags, list):
l.extend(linkflags)
else:
if linkflags:
l.append(linkflags)
if len(l) > 1:
flag_str = 'flags ' + ' '.join(l)
else:
flag_str = 'flag ' + ' '.join(l)
if flag_str > 28:
flag_str = flag_str[:28] + "..."
conf.start_msg('Checking for compilation %s support' % (flag_str,))
env = conf.env.derive()
if mode == 'cc':
mode = 'c'
if mode == 'cxx':
fname = 'test.cc'
env.append_value('CXXFLAGS', flag)
else:
fname = 'test.c'
env.append_value('CFLAGS', flag)
if linkflags is not None:
env.append_value("LINKFLAGS", linkflags)
try:
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)
conf.end_msg(ok)
return ok
def report_optional_feature(conf, name, caption, was_enabled, reason_not_enabled):
conf.env.append_value('NS3_OPTIONAL_FEATURES', [(name, caption, was_enabled, reason_not_enabled)])
def check_optional_feature(conf, name):
for (name1, caption, was_enabled, reason_not_enabled) in conf.env.NS3_OPTIONAL_FEATURES:
if name1 == name:
return was_enabled
raise KeyError("Feature %r not declared yet" % (name,))
# starting with waf 1.6, conf.check() becomes fatal by default if the
# test fails, this alternative method makes the test non-fatal, as it
# was in waf <= 1.5
def _check_nonfatal(conf, *args, **kwargs):
try:
return conf.check(*args, **kwargs)
except conf.errors.ConfigurationError:
return None
def configure(conf):
conf.load('relocation', tooldir=['waf-tools'])
# attach some extra methods
conf.check_nonfatal = types.MethodType(_check_nonfatal, conf)
conf.check_compilation_flag = types.MethodType(_check_compilation_flag, conf)
conf.report_optional_feature = types.MethodType(report_optional_feature, conf)
conf.check_optional_feature = types.MethodType(check_optional_feature, conf)
conf.env['NS3_OPTIONAL_FEATURES'] = []
conf.load('compiler_c')
conf.load('compiler_cxx')
conf.load('cflags', tooldir=['waf-tools'])
conf.load('command', tooldir=['waf-tools'])
conf.load('gnu_dirs')
env = conf.env
if Options.options.enable_gcov:
env['GCOV_ENABLED'] = True
env.append_value('CCFLAGS', '-fprofile-arcs')
env.append_value('CCFLAGS', '-ftest-coverage')
env.append_value('CXXFLAGS', '-fprofile-arcs')
env.append_value('CXXFLAGS', '-ftest-coverage')
env.append_value('LINKFLAGS', '-lgcov')
if Options.options.build_profile == 'debug':
env.append_value('DEFINES', 'NS3_ASSERT_ENABLE')
env.append_value('DEFINES', 'NS3_LOG_ENABLE')
env['PLATFORM'] = sys.platform
env['BUILD_PROFILE'] = Options.options.build_profile
if Options.options.build_profile == "release":
env['BUILD_SUFFIX'] = ''
else:
env['BUILD_SUFFIX'] = '-'+Options.options.build_profile
env['APPNAME'] = wutils.APPNAME
env['VERSION'] = wutils.VERSION
if conf.env['CXX_NAME'] in ['gcc', 'icc']:
if Options.options.build_profile == 'release':
env.append_value('CXXFLAGS', '-fomit-frame-pointer')
if Options.options.build_profile == 'optimized':
if conf.check_compilation_flag('-march=native'):
env.append_value('CXXFLAGS', '-march=native')
if sys.platform == 'win32':
env.append_value("LINKFLAGS", "-Wl,--enable-runtime-pseudo-reloc")
elif sys.platform == 'cygwin':
env.append_value("LINKFLAGS", "-Wl,--enable-auto-import")
cxx = env['CXX']
cxx_check_libstdcxx = cxx + ['-print-file-name=libstdc++.so']
p = subprocess.Popen(cxx_check_libstdcxx, stdout=subprocess.PIPE)
libstdcxx_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
env['ENABLE_STATIC_NS3'] = False
if Options.options.enable_static:
if Options.platform == 'darwin':
if conf.check_compilation_flag(flag=[], linkflags=['-Wl,-all_load']):
conf.report_optional_feature("static", "Static build", True, '')
env['ENABLE_STATIC_NS3'] = True
else:
conf.report_optional_feature("static", "Static build", False,
"Link flag -Wl,-all_load does not work")
else:
if conf.check_compilation_flag(flag=[], linkflags=['-Wl,--whole-archive,-Bstatic', '-Wl,-Bdynamic,--no-whole-archive']):
conf.report_optional_feature("static", "Static build", True, '')
env['ENABLE_STATIC_NS3'] = True
else:
conf.report_optional_feature("static", "Static build", False,
"Link flag -Wl,--whole-archive,-Bstatic does not work")
# Set this so that the lists won't be printed at the end of this
# configure command.
conf.env['PRINT_BUILT_MODULES_AT_END'] = False
conf.env['MODULES_NOT_BUILT'] = []
conf.recurse('bindings/python')
conf.recurse('src')
# Set the list of enabled modules.
if Options.options.enable_modules:
# Use the modules explicitly enabled.
conf.env['NS3_ENABLED_MODULES'] = ['ns3-'+mod for mod in
Options.options.enable_modules.split(',')]
else:
# Use the enabled modules list from the ns3 configuration file.
if modules_enabled[0] == 'all_modules':
# Enable all modules if requested.
conf.env['NS3_ENABLED_MODULES'] = conf.env['NS3_MODULES']
else:
# Enable the modules from the list.
conf.env['NS3_ENABLED_MODULES'] = ['ns3-'+mod for mod in
modules_enabled]
# Add the template module to the list of enabled modules that
# should not be built if this is a static build on Darwin. They
# don't work there for the template module, and this is probably
# because the template module has no source files.
if conf.env['ENABLE_STATIC_NS3'] and sys.platform == 'darwin':
conf.env['MODULES_NOT_BUILT'].append('template')
# Remove these modules from the list of enabled modules.
for not_built in conf.env['MODULES_NOT_BUILT']:
not_built_name = 'ns3-' + not_built
if not_built_name in conf.env['NS3_ENABLED_MODULES']:
conf.env['NS3_ENABLED_MODULES'].remove(not_built_name)
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:
conf.find_program('sudo', var='SUDO')
except WafError:
pass
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)
# Decide if tests will be built or not.
if Options.options.enable_tests:
# Tests were explicitly enabled.
env['ENABLE_TESTS'] = True
why_not_tests = "option --enable-tests selected"
elif Options.options.disable_tests:
# Tests were explicitly disabled.
env['ENABLE_TESTS'] = False
why_not_tests = "option --disable-tests selected"
else:
# Enable tests based on the ns3 configuration file.
env['ENABLE_TESTS'] = tests_enabled
if config_file_exists:
why_not_tests = "based on configuration file"
elif tests_enabled:
why_not_tests = "defaults to enabled"
else:
why_not_tests = "defaults to disabled"
conf.report_optional_feature("ENABLE_TESTS", "Build tests", env['ENABLE_TESTS'], why_not_tests)
# Decide if examples will be built or not.
if Options.options.enable_examples:
# Examples were explicitly enabled.
env['ENABLE_EXAMPLES'] = True
why_not_examples = "option --enable-examples selected"
elif Options.options.disable_examples:
# Examples were explicitly disabled.
env['ENABLE_EXAMPLES'] = False
why_not_examples = "option --disable-examples selected"
else:
# Enable examples based on the ns3 configuration file.
env['ENABLE_EXAMPLES'] = examples_enabled
if config_file_exists:
why_not_examples = "based on configuration file"
elif examples_enabled:
why_not_examples = "defaults to enabled"
else:
why_not_examples = "defaults to disabled"
env['EXAMPLE_DIRECTORIES'] = []
for dir in os.listdir('examples'):
if dir.startswith('.') or dir == 'CVS':
continue
if os.path.isdir(os.path.join('examples', dir)):
env['EXAMPLE_DIRECTORIES'].append(dir)
conf.report_optional_feature("ENABLE_EXAMPLES", "Build examples", env['ENABLE_EXAMPLES'],
why_not_examples)
env['VALGRIND_FOUND'] = False
try:
conf.find_program('valgrind', var='VALGRIND')
env['VALGRIND_FOUND'] = True
except WafError:
pass
# 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")
# for compiling C code, copy over the CXX* flags
conf.env.append_value('CCFLAGS', conf.env['CXXFLAGS'])
def add_gcc_flag(flag):
if env['COMPILER_CXX'] == 'g++' and 'CXXFLAGS' not in os.environ:
if conf.check_compilation_flag(flag, mode='cxx'):
env.append_value('CXXFLAGS', flag)
if env['COMPILER_CC'] == 'gcc' and 'CCFLAGS' not in os.environ:
if conf.check_compilation_flag(flag, mode='cc'):
env.append_value('CCFLAGS', flag)
add_gcc_flag('-Wno-error=deprecated-declarations')
add_gcc_flag('-fstrict-aliasing')
add_gcc_flag('-Wstrict-aliasing')
try:
conf.find_program('doxygen', var='DOXYGEN')
except WafError:
pass
# append user defined flags after all our ones
for (confvar, envvar) in [['CCFLAGS', 'CCFLAGS_EXTRA'],
['CXXFLAGS', 'CXXFLAGS_EXTRA'],
['LINKFLAGS', 'LINKFLAGS_EXTRA'],
['LINKFLAGS', 'LDFLAGS_EXTRA']]:
if envvar in os.environ:
value = shlex.split(os.environ[envvar])
conf.env.append_value(confvar, value)
# 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'
color = 'GREEN'
else:
status = 'not enabled (%s)' % reason_not_enabled
color = 'RED'
print "%-30s: %s%s%s" % (caption, Logs.colors_lst[color], status, Logs.colors_lst['NORMAL'])
class SuidBuild_task(Task.Task):
"""task that makes a binary Suid
"""
after = 'link'
def __init__(self, *args, **kwargs):
super(SuidBuild_task, self).__init__(*args, **kwargs)
self.m_display = 'build-suid'
try:
program_obj = wutils.find_program(self.generator.name, self.generator.env)
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):
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"
try:
st = os.stat(self.filename)
except OSError:
return Task.ASK_LATER
if st.st_uid == 0:
return Task.SKIP_ME
else:
return Task.RUN_ME
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
program.target = "%s%s-%s%s" % (wutils.APPNAME, wutils.VERSION, name, bld.env.BUILD_SUFFIX)
if bld.env['ENABLE_SUDO']:
program.create_task("SuidBuild")
bld.set_group(grp)
return program
def create_ns3_program(bld, name, dependencies=('core',)):
program = bld(features='cxx cxxprogram')
program.is_ns3_program = True
program.name = name
program.target = "%s%s-%s%s" % (wutils.APPNAME, wutils.VERSION, name, bld.env.BUILD_SUFFIX)
# Each of the modules this program depends on has its own library.
program.ns3_module_dependencies = ['ns3-'+dep for dep in dependencies]
program.includes = "#"
program.use = program.ns3_module_dependencies
if program.env['ENABLE_STATIC_NS3']:
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':
# All ELF platforms are impacted but only the gcc compiler has a flag to fix it.
if 'gcc' in (program.env.CXX_NAME, program.env.CC_NAME):
program.env.append_value ('SHLIB_MARKER', '-Wl,--no-as-needed')
return program
def register_ns3_script(bld, name, dependencies=('core',)):
ns3_module_dependencies = ['ns3-'+dep for dep in dependencies]
bld.env.append_value('NS3_SCRIPT_DEPENDENCIES', [(name, ns3_module_dependencies)])
def add_examples_programs(bld):
env = bld.env
if env['ENABLE_EXAMPLES']:
for dir in os.listdir('examples'):
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']]
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.source = obj.path.ant_glob('*.cc')
obj.target = filename
obj.name = obj.target
obj.install_path = None
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
obj.install_path = None
def _get_all_task_gen(self):
for group in self.groups:
for taskgen in group:
yield taskgen
# ok, so WAF does not provide an API to prevent an
# arbitrary taskgen from running; we have to muck around with
# WAF internal state, something that might stop working if
# WAF is upgraded...
def _exclude_taskgen(self, taskgen):
for group in self.groups:
for tg1 in group:
if tg1 is taskgen:
group.remove(tg1)
break
else:
continue
break
def _find_ns3_module(self, name):
for obj in _get_all_task_gen(self):
# disable the modules themselves
if hasattr(obj, "is_ns3_module") and obj.name == name:
return obj
raise KeyError(name)
def build(bld):
env = bld.env
# If --enabled-modules option was given, then print a warning
# message and exit this function.
if Options.options.enable_modules:
Logs.warn("No modules were built. Use waf configure --enable-modules to enable modules.")
return
bld.env['NS3_MODULES_WITH_TEST_LIBRARIES'] = []
bld.env['NS3_ENABLED_MODULE_TEST_LIBRARIES'] = []
bld.env['NS3_SCRIPT_DEPENDENCIES'] = []
bld.env['NS3_RUNNABLE_PROGRAMS'] = []
bld.env['NS3_RUNNABLE_SCRIPTS'] = []
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.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.__class__.all_task_gen = property(_get_all_task_gen)
bld.exclude_taskgen = types.MethodType(_exclude_taskgen, bld)
bld.find_ns3_module = types.MethodType(_find_ns3_module, bld)
# Clean documentation build directories; other cleaning happens later
if bld.cmd == 'clean':
_cleandocs()
# process subfolders from here
bld.recurse('src')
# If modules have been enabled, then set lists of enabled modules
# and enabled module test libraries.
if env['NS3_ENABLED_MODULES']:
modules = env['NS3_ENABLED_MODULES']
# Find out about additional modules that need to be enabled
# due to dependency constraints.
changed = True
while changed:
changed = False
for module in modules:
module_obj = bld.get_tgen_by_name(module)
if module_obj is None:
raise ValueError("module %s not found" % module)
# Each enabled module has its own library.
for dep in module_obj.use:
if not dep.startswith('ns3-'):
continue
if dep not in modules:
modules.append(dep)
changed = True
env['NS3_ENABLED_MODULES'] = modules
# If tests are being built, then set the list of the enabled
# module test libraries.
if env['ENABLE_TESTS']:
for (mod, testlib) in bld.env['NS3_MODULES_WITH_TEST_LIBRARIES']:
if mod in bld.env['NS3_ENABLED_MODULES']:
bld.env.append_value('NS3_ENABLED_MODULE_TEST_LIBRARIES', testlib)
add_examples_programs(bld)
add_scratch_programs(bld)
if env['NS3_ENABLED_MODULES']:
modules = env['NS3_ENABLED_MODULES']
# Exclude the programs other misc task gens that depend on disabled modules
for obj in list(bld.all_task_gen):
# check for ns3moduleheader_taskgen
if 'ns3moduleheader' in getattr(obj, "features", []):
if ("ns3-%s" % obj.module) not in modules:
obj.mode = 'remove' # tell it to remove headers instead of installing
# check for programs
if hasattr(obj, 'ns3_module_dependencies'):
# this is an NS-3 program (bld.create_ns3_program)
program_built = True
for dep in obj.ns3_module_dependencies:
if dep not in modules: # prog. depends on a module that isn't enabled?
bld.exclude_taskgen(obj)
program_built = False
break
# Add this program to the list if all of its
# dependencies will be built.
if program_built:
object_name = "%s%s-%s%s" % (wutils.APPNAME, wutils.VERSION,
obj.name, bld.env.BUILD_SUFFIX)
# Get the relative path to the program from the
# 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)
# disable the modules themselves
if hasattr(obj, "is_ns3_module") and obj.name not in modules:
bld.exclude_taskgen(obj) # kill the module
# disable the module test libraries
if hasattr(obj, "is_ns3_module_test_library"):
if not env['ENABLE_TESTS'] or (obj.module_name not in modules):
bld.exclude_taskgen(obj) # kill the module test library
# disable the ns3header_taskgen
if 'ns3header' in getattr(obj, "features", []):
if ("ns3-%s" % obj.module) not in modules:
obj.mode = 'remove' # tell it to remove headers instead of installing
# disable pcfile taskgens for disabled modules
if 'ns3pcfile' in getattr(obj, "features", []):
if obj.module not in bld.env.NS3_ENABLED_MODULES:
bld.exclude_taskgen(obj)
if env['NS3_ENABLED_MODULES']:
env['NS3_ENABLED_MODULES'] = list(modules)
# Determine which scripts will be runnable.
for (script, dependencies) in bld.env['NS3_SCRIPT_DEPENDENCIES']:
script_runnable = True
for dep in dependencies:
if dep not in modules:
script_runnable = False
break
# Add this script to the list if all of its dependencies will
# be built.
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.
bld.env['PRINT_BUILT_MODULES_AT_END'] = True
# Do not print the modules built if build command was "clean"
if bld.cmd == 'clean':
bld.env['PRINT_BUILT_MODULES_AT_END'] = False
if Options.options.run:
# Check that the requested program name is valid
program_name, dummy_program_argv = wutils.get_run_program(Options.options.run, wutils.get_command_template(env))
# When --run'ing a program, tell WAF to only build that program,
# nothing more; this greatly speeds up compilation when all you
# want to do is run a test program.
Options.options.targets += ',' + os.path.basename(program_name)
if getattr(Options.options, "visualize", False):
program_obj = wutils.find_program(program_name, bld.env)
program_obj.use.append('ns3-visualizer')
for gen in bld.all_task_gen:
if type(gen).__name__ in ['ns3header_taskgen', 'ns3moduleheader_taskgen']:
gen.post()
bld.env['PRINT_BUILT_MODULES_AT_END'] = False
if Options.options.doxygen_no_build:
_doxygen(bld)
raise SystemExit(0)
def _cleandir(name):
try:
shutil.rmtree(name)
except:
pass
def _cleandocs():
_cleandir('doc/html')
_cleandir('doc/manual/build')
_cleandir('doc/manual/source-temp')
_cleandir('doc/tutorial/build')
_cleandir('doc/tutorial-pt-br/build')
_cleandir('doc/models/build')
_cleandir('doc/models/source-temp')
# 'distclean' typically only cleans out build/ directory
# Here we clean out any build or documentation artifacts not in build/
def distclean(ctx):
_cleandocs()
# Now call waf's normal distclean
Scripting.distclean(ctx)
def shutdown(ctx):
bld = wutils.bld
if wutils.bld is None:
return
env = bld.env
# Only print the lists if a build was done.
if (env['PRINT_BUILT_MODULES_AT_END']):
# Print the list of built modules.
print
print 'Modules built:'
names_without_prefix = []
for name in env['NS3_ENABLED_MODULES']:
name1 = name[len('ns3-'):]
if name not in env.MODULAR_BINDINGS_MODULES:
name1 += " (no Python)"
names_without_prefix.append(name1)
print_module_names(names_without_prefix)
print
# Print the list of enabled modules that were not built.
if env['MODULES_NOT_BUILT']:
print 'Modules not built (see ns-3 tutorial for explanation):'
print_module_names(env['MODULES_NOT_BUILT'])
print
# Set this so that the lists won't be printed until the next
# build is done.
bld.env['PRINT_BUILT_MODULES_AT_END'] = False
# Write the build status file.
build_status_file = os.path.join(bld.out_dir, 'build-status.py')
out = open(build_status_file, 'w')
out.write('#! /usr/bin/env python\n')
out.write('\n')
out.write('# Programs that are runnable.\n')
out.write('ns3_runnable_programs = ' + str(env['NS3_RUNNABLE_PROGRAMS']) + '\n')
out.write('\n')
out.write('# Scripts that are runnable.\n')
out.write('ns3_runnable_scripts = ' + str(env['NS3_RUNNABLE_SCRIPTS']) + '\n')
out.write('\n')
out.close()
if Options.options.lcov_report:
lcov_report(bld)
if Options.options.run:
wutils.run_program(Options.options.run, env, wutils.get_command_template(env),
visualize=Options.options.visualize)
raise SystemExit(0)
if Options.options.pyrun:
wutils.run_python_program(Options.options.pyrun, env,
visualize=Options.options.visualize)
raise SystemExit(0)
if Options.options.shell:
raise WafError("Please run `./waf shell' now, instead of `./waf --shell'")
if Options.options.check:
raise WafError("Please run `./test.py' now, instead of `./waf --check'")
check_shell(bld)
class CheckContext(Context.Context):
"""run the equivalent of the old ns-3 unit tests using test.py"""
cmd = 'check'
def execute(self):
# first we execute the build
bld = Context.create_context("build")
bld.options = Options.options # provided for convenience
bld.cmd = "build"
bld.execute()
wutils.bld = bld
wutils.run_python_program("test.py -n -c core", bld.env)
class print_introspected_doxygen_task(Task.TaskBase):
after = 'cxx link'
color = 'BLUE'
def __init__(self, bld):
self.bld = bld
super(print_introspected_doxygen_task, self).__init__(generator=self)
def __str__(self):
return 'print-introspected-doxygen\n'
def runnable_status(self):
return Task.RUN_ME
def run(self):
## generate the trace sources list docs
env = wutils.bld.env
proc_env = wutils.get_proc_env()
try:
program_obj = wutils.find_program('print-introspected-doxygen', env)
except ValueError: # could happen if print-introspected-doxygen is
# not built because of waf configure
# --enable-modules=xxx
pass
else:
prog = program_obj.path.find_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')
if subprocess.Popen([prog], stdout=doxygen_out, env=proc_env).wait():
raise SystemExit(1)
doxygen_out.close()
# Create a text file with the introspected information.
text_out = open(os.path.join('doc', 'ns3-object.txt'), 'w')
if subprocess.Popen([prog, '--output-text'], stdout=text_out, env=proc_env).wait():
raise SystemExit(1)
text_out.close()
class run_python_unit_tests_task(Task.TaskBase):
after = 'cxx link'
color = 'BLUE'
def __init__(self, bld):
self.bld = bld
super(run_python_unit_tests_task, self).__init__(generator=self)