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
|
# Samba automatic dependency handling and project rules
import Build, os, re, Environment
from samba_utils import *
from samba_autoconf import *
from samba_bundled import BUILTIN_LIBRARY
@conf
def ADD_GLOBAL_DEPENDENCY(ctx, dep):
'''add a dependency for all binaries and libraries'''
if not 'GLOBAL_DEPENDENCIES' in ctx.env:
ctx.env.GLOBAL_DEPENDENCIES = []
ctx.env.GLOBAL_DEPENDENCIES.append(dep)
def TARGET_ALIAS(bld, target, alias):
'''define an alias for a target name'''
cache = LOCAL_CACHE(bld, 'TARGET_ALIAS')
if alias in cache:
print("Target alias %s already set to %s : newalias %s" % (alias, cache[alias], target))
raise
cache[alias] = target
Build.BuildContext.TARGET_ALIAS = TARGET_ALIAS
@conf
def SET_SYSLIB_DEPS(conf, target, deps):
'''setup some implied dependencies for a SYSLIB'''
cache = LOCAL_CACHE(conf, 'SYSLIB_DEPS')
cache[target] = deps
def EXPAND_ALIAS(bld, target):
'''expand a target name via an alias'''
aliases = LOCAL_CACHE(bld, 'TARGET_ALIAS')
if target in aliases:
return aliases[target]
return target
Build.BuildContext.EXPAND_ALIAS = EXPAND_ALIAS
def expand_subsystem_deps(bld):
'''expand the reverse dependencies resulting from subsystem
attributes of modules'''
subsystems = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
aliases = LOCAL_CACHE(bld, 'TARGET_ALIAS')
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
for s in subsystems:
if s in aliases:
s = aliases[s]
bld.ASSERT(s in targets, "Subsystem target %s not declared" % s)
type = targets[s]
if type == 'DISABLED' or type == 'EMPTY':
continue
t = bld.name_to_obj(s, bld.env)
bld.ASSERT(t is not None, "Subsystem target %s not found" % s)
for d in subsystems[s]:
type = targets[d['TARGET']]
if type != 'DISABLED' and type != 'EMPTY':
t.samba_deps_extended.append(d['TARGET'])
t2 = bld.name_to_obj(d['TARGET'], bld.env)
t2.samba_includes_extended.extend(t.samba_includes_extended)
t2.samba_deps_extended.extend(t.samba_deps_extended)
t.samba_deps_extended = unique_list(t.samba_deps_extended)
def build_dependencies(self):
'''This builds the dependency list for a target. It runs after all the targets are declared
The reason this is not just done in the SAMBA_*() rules is that we have no way of knowing
the full dependency list for a target until we have all of the targets declared.
'''
if self.samba_type in ['LIBRARY', 'BINARY', 'PYTHON']:
self.uselib = list(self.final_syslibs)
self.uselib_local = list(self.final_libs)
self.add_objects = list(self.final_objects)
# extra link flags from pkg_config
libs = self.final_syslibs.copy()
(ccflags, ldflags) = library_flags(self, list(libs))
new_ldflags = getattr(self, 'ldflags', [])
new_ldflags.extend(ldflags)
self.ldflags = new_ldflags
debug('deps: computed dependencies for target %s: uselib=%s uselib_local=%s add_objects=%s',
self.sname, self.uselib, self.uselib_local, self.add_objects)
if self.samba_type in ['SUBSYSTEM']:
# this is needed for the ccflags of libs that come from pkg_config
self.uselib = list(self.direct_syslibs)
if getattr(self, 'uselib', None):
up_list = []
for l in self.uselib:
up_list.append(l.upper())
self.uselib = up_list
def build_includes(self):
'''This builds the right set of includes for a target.
One tricky part of this is that the includes= attribute for a
target needs to use paths which are relative to that targets
declaration directory (which we can get at via t.path).
The way this works is the includes list gets added as
samba_includes in the main build task declaration. Then this
function runs after all of the tasks are declared, and it
processes the samba_includes attribute to produce a includes=
attribute
'''
if getattr(self, 'samba_includes', None) is None:
return
bld = self.bld
inc_deps = includes_objects(bld, self, set(), {})
includes = []
# maybe add local includes
if getattr(self, 'local_include', True) == True and getattr(self, 'local_include_first', True):
includes.append('.')
includes.extend(self.samba_includes_extended)
if 'EXTRA_INCLUDES' in bld.env:
includes.extend(bld.env['EXTRA_INCLUDES'])
includes.append('#')
inc_set = set()
inc_abs = []
for d in inc_deps:
t = bld.name_to_obj(d, bld.env)
bld.ASSERT(t is not None, "Unable to find dependency %s for %s" % (d, self.sname))
inclist = getattr(t, 'samba_includes_extended', [])
if getattr(t, 'local_include', True) == True:
inclist.append('.')
if inclist == []:
continue
tpath = t.samba_abspath
for inc in inclist:
npath = tpath + '/' + inc
if not npath in inc_set:
inc_abs.append(npath)
inc_set.add(npath)
mypath = self.path.abspath(bld.env)
for inc in inc_abs:
relpath = os_path_relpath(inc, mypath)
includes.append(relpath)
if getattr(self, 'local_include', True) == True and not getattr(self, 'local_include_first', True):
includes.append('.')
# now transform the includes list to be relative to the top directory
# which is represented by '#' in waf. This allows waf to cache the
# includes lists more efficiently
includes_top = []
for i in includes:
if i[0] == '#':
# some are already top based
includes_top.append(i)
continue
absinc = os.path.join(self.path.abspath(), i)
relinc = os_path_relpath(absinc, self.bld.srcnode.abspath())
includes_top.append('#' + relinc)
self.includes = unique_list(includes_top)
debug('deps: includes for target %s: includes=%s',
self.sname, self.includes)
def add_init_functions(self):
'''This builds the right set of init functions'''
bld = self.bld
subsystems = LOCAL_CACHE(bld, 'INIT_FUNCTIONS')
# cope with the separated object lists from BINARY and LIBRARY targets
sname = self.sname
if sname.endswith('.objlist'):
sname = sname[0:-8]
modules = []
if sname in subsystems:
modules.append(sname)
m = getattr(self, 'samba_modules', None)
if m is not None:
modules.extend(TO_LIST(m))
m = getattr(self, 'samba_subsystem', None)
if m is not None:
modules.append(m)
if modules == []:
return
sentinal = getattr(self, 'init_function_sentinal', 'NULL')
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
cflags = getattr(self, 'samba_cflags', [])[:]
for m in modules:
bld.ASSERT(m in subsystems,
"No init_function defined for module '%s' in target '%s'" % (m, self.sname))
init_fn_list = []
for d in subsystems[m]:
if targets[d['TARGET']] != 'DISABLED':
init_fn_list.append(d['INIT_FUNCTION'])
if init_fn_list == []:
cflags.append('-DSTATIC_%s_MODULES=%s' % (m, sentinal))
else:
cflags.append('-DSTATIC_%s_MODULES=%s' % (m, ','.join(init_fn_list) + ',' + sentinal))
self.ccflags = cflags
def check_duplicate_sources(bld, tgt_list):
'''see if we are compiling the same source file into multiple
subsystem targets for the same library or binary'''
debug('deps: checking for duplicate sources')
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
ret = True
seen = set()
for t in tgt_list:
obj_sources = getattr(t, 'source', '')
tpath = os_path_relpath(t.path.abspath(bld.env), t.env['BUILD_DIRECTORY'] + '/default')
obj_sources = bld.SUBDIR(tpath, obj_sources)
t.samba_source_set = set(TO_LIST(obj_sources))
for t in tgt_list:
if not targets[t.sname] in [ 'LIBRARY', 'BINARY', 'PYTHON' ]:
continue
sources = []
for obj in t.add_objects:
t2 = t.bld.name_to_obj(obj, bld.env)
source_set = getattr(t2, 'samba_source_set', set())
sources.append( { 'dep':obj, 'src':source_set} )
for s in sources:
for s2 in sources:
if s['dep'] == s2['dep']: continue
common = s['src'].intersection(s2['src'])
if common.difference(seen):
print("Target %s has duplicate source files in %s and %s : %s" % (t.sname,
s['dep'], s2['dep'],
common))
seen = seen.union(common)
ret = False
return ret
def check_orpaned_targets(bld, tgt_list):
'''check if any build targets are orphaned'''
target_dict = LOCAL_CACHE(bld, 'TARGET_TYPE')
debug('deps: checking for orphaned targets')
for t in tgt_list:
if getattr(t, 'samba_used', False) == True:
continue
type = target_dict[t.sname]
if not type in ['BINARY', 'LIBRARY', 'MODULE', 'ET', 'PYTHON']:
if re.search('^PIDL_', t.sname) is None:
print "Target %s of type %s is unused by any other target" % (t.sname, type)
def show_final_deps(bld, tgt_list):
'''show the final dependencies for all targets'''
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
for t in tgt_list:
if not targets[t.sname] in ['LIBRARY', 'BINARY', 'PYTHON']:
continue
debug('deps: final dependencies for target %s: uselib=%s uselib_local=%s add_objects=%s',
t.sname, t.uselib, t.uselib_local, t.add_objects)
def add_samba_attributes(bld, tgt_list):
'''ensure a target has a the required samba attributes'''
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
for t in tgt_list:
if t.name != '':
t.sname = t.name
else:
t.sname = t.target
t.samba_type = targets[t.sname]
t.samba_abspath = t.path.abspath(bld.env)
t.samba_deps_extended = t.samba_deps[:]
t.samba_includes_extended = TO_LIST(t.samba_includes)[:]
t.ccflags = getattr(t, 'samba_cflags', '')
def build_direct_deps(bld, tgt_list):
'''build the direct_objects and direct_libs sets for each target'''
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
syslib_deps = LOCAL_CACHE(bld, 'SYSLIB_DEPS')
global_deps = bld.env.GLOBAL_DEPENDENCIES
for t in tgt_list:
t.direct_objects = set()
t.direct_libs = set()
t.direct_syslibs = set()
deps = t.samba_deps_extended
deps.extend(global_deps)
for d in deps:
d = EXPAND_ALIAS(bld, d)
if d == t.sname: continue
if not d in targets:
print "Unknown dependency %s in %s" % (d, t.sname)
raise
if targets[d] in [ 'EMPTY', 'DISABLED' ]:
continue
if targets[d] == 'SYSLIB':
t.direct_syslibs.add(d)
if d in syslib_deps:
for implied in TO_LIST(syslib_deps[d]):
if BUILTIN_LIBRARY(bld, implied):
t.direct_objects.add(implied)
else:
t.direct_libs.add(implied)
continue
t2 = bld.name_to_obj(d, bld.env)
if t2 is None:
print "no task %s type %s" % (d, targets[d])
if t2.samba_type in [ 'LIBRARY', 'MODULE' ]:
t.direct_libs.add(d)
elif t2.samba_type in [ 'SUBSYSTEM', 'ASN1', 'PYTHON' ]:
t.direct_objects.add(d)
debug('deps: built direct dependencies')
def dependency_loop(loops, t, target):
'''add a dependency loop to the loops dictionary'''
if t.sname == target:
return
if not target in loops:
loops[target] = set()
if not t.sname in loops[target]:
loops[target].add(t.sname)
def indirect_libs(bld, t, chain, loops):
'''recursively calculate the indirect library dependencies for a target
An indirect library is a library that results from a dependency on
a subsystem
'''
ret = getattr(t, 'indirect_libs', None)
if ret is not None:
return ret
ret = set()
for obj in t.direct_objects:
if obj in chain:
dependency_loop(loops, t, obj)
continue
chain.add(obj)
t2 = bld.name_to_obj(obj, bld.env)
r2 = indirect_libs(bld, t2, chain, loops)
chain.remove(obj)
ret = ret.union(t2.direct_libs)
ret = ret.union(r2)
for obj in indirect_objects(bld, t, set(), loops):
if obj in chain:
dependency_loop(loops, t, obj)
continue
chain.add(obj)
t2 = bld.name_to_obj(obj, bld.env)
r2 = indirect_libs(bld, t2, chain, loops)
chain.remove(obj)
ret = ret.union(t2.direct_libs)
ret = ret.union(r2)
t.indirect_libs = ret
return ret
def indirect_objects(bld, t, chain, loops):
'''recursively calculate the indirect object dependencies for a target
indirect objects are the set of objects from expanding the
subsystem dependencies
'''
ret = getattr(t, 'indirect_objects', None)
if ret is not None: return ret
ret = set()
for lib in t.direct_objects:
if lib in chain:
dependency_loop(loops, t, lib)
continue
chain.add(lib)
t2 = bld.name_to_obj(lib, bld.env)
r2 = indirect_objects(bld, t2, chain, loops)
chain.remove(lib)
ret = ret.union(t2.direct_objects)
ret = ret.union(r2)
t.indirect_objects = ret
return ret
def extended_objects(bld, t, chain):
'''recursively calculate the extended object dependencies for a target
extended objects are the union of:
- direct objects
- indirect objects
- direct and indirect objects of all direct and indirect libraries
'''
ret = getattr(t, 'extended_objects', None)
if ret is not None: return ret
ret = set()
ret = ret.union(t.direct_objects)
ret = ret.union(t.indirect_objects)
for lib in t.direct_libs:
if lib in chain:
continue
t2 = bld.name_to_obj(lib, bld.env)
chain.add(lib)
r2 = extended_objects(bld, t2, chain)
chain.remove(lib)
ret = ret.union(t2.direct_objects)
ret = ret.union(t2.indirect_objects)
ret = ret.union(r2)
t.extended_objects = ret
return ret
def includes_objects(bld, t, chain, inc_loops):
'''recursively calculate the includes object dependencies for a target
includes dependencies come from either library or object dependencies
'''
ret = getattr(t, 'includes_objects', None)
if ret is not None:
return ret
ret = t.direct_objects.copy()
ret = ret.union(t.direct_libs)
for obj in t.direct_objects:
if obj in chain:
dependency_loop(inc_loops, t, obj)
continue
chain.add(obj)
t2 = bld.name_to_obj(obj, bld.env)
r2 = includes_objects(bld, t2, chain, inc_loops)
chain.remove(obj)
ret = ret.union(t2.direct_objects)
ret = ret.union(r2)
for lib in t.direct_libs:
if lib in chain:
dependency_loop(inc_loops, t, lib)
continue
chain.add(lib)
t2 = bld.name_to_obj(lib, bld.env)
r2 = includes_objects(bld, t2, chain, inc_loops)
chain.remove(lib)
ret = ret.union(t2.direct_objects)
ret = ret.union(r2)
t.includes_objects = ret
return ret
def break_dependency_loops(bld, tgt_list):
'''find and break dependency loops'''
loops = {}
inc_loops = {}
# build up the list of loops
for t in tgt_list:
indirect_objects(bld, t, set(), loops)
indirect_libs(bld, t, set(), loops)
includes_objects(bld, t, set(), inc_loops)
# break the loops
for t in tgt_list:
if t.sname in loops:
for attr in ['direct_objects', 'indirect_objects', 'direct_libs', 'indirect_libs']:
objs = getattr(t, attr, set())
setattr(t, attr, objs.difference(loops[t.sname]))
for loop in loops:
debug('deps: Found dependency loops for target %s : %s', loop, loops[loop])
for loop in inc_loops:
debug('deps: Found include loops for target %s : %s', loop, inc_loops[loop])
# expand the loops mapping by one level
for loop in loops.copy():
for tgt in loops[loop]:
if tgt in loops:
loops[loop] = loops[loop].union(loops[tgt])
for loop in inc_loops.copy():
for tgt in inc_loops[loop]:
if tgt in inc_loops:
inc_loops[loop] = inc_loops[loop].union(inc_loops[tgt])
# expand indirect subsystem and library loops
for loop in loops.copy():
t = bld.name_to_obj(loop, bld.env)
if t.samba_type in ['SUBSYSTEM']:
loops[loop] = loops[loop].union(t.indirect_objects)
loops[loop] = loops[loop].union(t.direct_objects)
if t.samba_type in ['LIBRARY','PYTHON']:
loops[loop] = loops[loop].union(t.indirect_libs)
loops[loop] = loops[loop].union(t.direct_libs)
if loop in loops[loop]:
loops[loop].remove(loop)
# expand indirect includes loops
for loop in inc_loops.copy():
t = bld.name_to_obj(loop, bld.env)
inc_loops[loop] = inc_loops[loop].union(t.includes_objects)
if loop in inc_loops[loop]:
inc_loops[loop].remove(loop)
# add in the replacement dependencies
for t in tgt_list:
for loop in loops:
for attr in ['direct_objects', 'indirect_objects', 'direct_libs', 'indirect_libs']:
objs = getattr(t, attr, set())
if loop in objs:
diff = loops[loop].difference(objs)
if t.sname in diff:
diff.remove(t.sname)
if diff:
debug('deps: Expanded target %s of type %s from loop %s by %s', t.sname, t.samba_type, loop, diff)
objs = objs.union(diff)
setattr(t, attr, objs)
for loop in inc_loops:
objs = getattr(t, 'includes_objects', set())
if loop in objs:
diff = inc_loops[loop].difference(objs)
if t.sname in diff:
diff.remove(t.sname)
if diff:
debug('deps: Expanded target %s includes of type %s from loop %s by %s', t.sname, t.samba_type, loop, diff)
objs = objs.union(diff)
setattr(t, 'includes_objects', objs)
def calculate_final_deps(bld, tgt_list, loops):
'''calculate the final library and object dependencies'''
for t in tgt_list:
# start with the maximum possible list
t.final_libs = t.direct_libs.union(indirect_libs(bld, t, set(), loops))
t.final_objects = t.direct_objects.union(indirect_objects(bld, t, set(), loops))
for t in tgt_list:
# don't depend on ourselves
if t.sname in t.final_libs:
t.final_libs.remove(t.sname)
if t.sname in t.final_objects:
t.final_objects.remove(t.sname)
# find any library loops
for t in tgt_list:
if t.samba_type in ['LIBRARY', 'PYTHON']:
for l in t.final_libs.copy():
t2 = bld.name_to_obj(l, bld.env)
if t.sname in t2.final_libs:
# we could break this in either direction. If one of the libraries
# has a version number, and will this be distributed publicly, then
# we should make it the lower level library in the DAG
debug('deps: removing library loop %s from %s', t.sname, t2.sname)
dependency_loop(loops, t, t2.sname)
t2.final_libs.remove(t.sname)
rely_on = {}
for type in ['BINARY', 'PYTHON', 'LIBRARY']:
for t in tgt_list:
if t.samba_type != type: continue
# if we will indirectly link to a target then we don't need it
new = t.final_objects.copy()
for l in t.final_libs:
t2 = bld.name_to_obj(l, bld.env)
t2_obj = extended_objects(bld, t2, set())
dup = new.intersection(t2_obj)
if dup:
debug('deps: removing dups from %s of type %s: %s also in %s %s',
t.sname, t.samba_type, dup, t2.samba_type, l)
new = new.difference(dup)
changed = True
if not l in rely_on:
rely_on[l] = set()
rely_on[l] = rely_on[l].union(dup)
t.final_objects = new
# add back in any objects that were relied upon by the reduction rules
for r in rely_on:
t = bld.name_to_obj(r, bld.env)
t.final_objects = t.final_objects.union(rely_on[r])
for loop in loops:
debug('deps: Found dependency loops for target %s : %s', loop, loops[loop])
# we now need to make corrections for any library loops we broke up
# any target that depended on the target of the loop and doesn't
# depend on the source of the loop needs to get the loop source added
for type in ['BINARY','PYTHON','LIBRARY','BINARY']:
for t in tgt_list:
if t.samba_type != type: continue
for loop in loops:
if loop in t.final_libs:
diff = loops[loop].difference(t.final_libs)
if t.sname in diff:
diff.remove(t.sname)
if diff:
debug('deps: Expanded target %s by loop %s libraries %s', t.sname, loop, diff)
t.final_libs = t.final_libs.union(diff)
# add in any syslib dependencies
for t in tgt_list:
if not t.samba_type in ['BINARY','PYTHON','LIBRARY']:
continue
syslibs = set()
for d in t.final_objects:
t2 = bld.name_to_obj(d, bld.env)
syslibs = syslibs.union(t2.direct_syslibs)
# this adds the indirect syslibs as well, which may not be needed
# depending on the linker flags
for d in t.final_libs:
t2 = bld.name_to_obj(d, bld.env)
syslibs = syslibs.union(t2.direct_syslibs)
t.final_syslibs = syslibs
debug('deps: removed duplicate dependencies')
######################################################################
# this provides a way to save our dependency calculations between runs
savedeps_version = 3
savedeps_inputs = ['samba_deps', 'samba_includes', 'local_include', 'local_include_first', 'samba_cflags', 'source']
savedeps_outputs = ['uselib', 'uselib_local', 'add_objects', 'includes', 'ccflags']
savedeps_outenv = ['INC_PATHS']
savedeps_caches = ['GLOBAL_DEPENDENCIES', 'TARGET_ALIAS', 'TARGET_TYPE', 'INIT_FUNCTIONS', 'SYSLIB_DEPS']
savedeps_files = ['buildtools/wafsamba/samba_deps.py']
def save_samba_deps(bld, tgt_list):
'''save the dependency calculations between builds, to make
further builds faster'''
denv = Environment.Environment()
denv.version = savedeps_version
denv.savedeps_inputs = savedeps_inputs
denv.savedeps_outputs = savedeps_outputs
denv.input = {}
denv.output = {}
denv.outenv = {}
denv.caches = {}
denv.files = {}
for f in savedeps_files:
denv.files[f] = os.stat(os.path.join(bld.srcnode.abspath(), f)).st_mtime
for c in savedeps_caches:
denv.caches[c] = LOCAL_CACHE(bld, c)
for t in tgt_list:
# save all the input attributes for each target
tdeps = {}
for attr in savedeps_inputs:
v = getattr(t, attr, None)
if v is not None:
tdeps[attr] = v
if tdeps != {}:
denv.input[t.sname] = tdeps
# save all the output attributes for each target
tdeps = {}
for attr in savedeps_outputs:
v = getattr(t, attr, None)
if v is not None:
tdeps[attr] = v
if tdeps != {}:
denv.output[t.sname] = tdeps
tdeps = {}
for attr in savedeps_outenv:
if attr in t.env:
tdeps[attr] = t.env[attr]
if tdeps != {}:
denv.outenv[t.sname] = tdeps
depsfile = os.path.join(bld.bdir, "sambadeps")
denv.store(depsfile)
def load_samba_deps(bld, tgt_list):
'''load a previous set of build dependencies if possible'''
depsfile = os.path.join(bld.bdir, "sambadeps")
denv = Environment.Environment()
try:
debug('deps: checking saved dependencies')
denv.load(depsfile)
if (denv.version != savedeps_version or
denv.savedeps_inputs != savedeps_inputs or
denv.savedeps_outputs != savedeps_outputs):
return False
except:
return False
# check if critical files have changed
for f in savedeps_files:
if f not in denv.files:
return False
if denv.files[f] != os.stat(os.path.join(bld.srcnode.abspath(), f)).st_mtime:
return False
# check if caches are the same
for c in savedeps_caches:
if c not in denv.caches or denv.caches[c] != LOCAL_CACHE(bld, c):
return False
# check inputs are the same
for t in tgt_list:
tdeps = {}
for attr in savedeps_inputs:
v = getattr(t, attr, None)
if v is not None:
tdeps[attr] = v
if t.sname in denv.input:
olddeps = denv.input[t.sname]
else:
olddeps = {}
if tdeps != olddeps:
#print '%s: \ntdeps=%s \nodeps=%s' % (t.sname, tdeps, olddeps)
return False
# put outputs in place
for t in tgt_list:
if not t.sname in denv.output: continue
tdeps = denv.output[t.sname]
for a in tdeps:
setattr(t, a, tdeps[a])
# put output env vars in place
for t in tgt_list:
if not t.sname in denv.outenv: continue
tdeps = denv.outenv[t.sname]
for a in tdeps:
t.env[a] = tdeps[a]
debug('deps: loaded saved dependencies')
return True
def check_project_rules(bld):
'''check the project rules - ensuring the targets are sane'''
targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
loops = {}
inc_loops = {}
# build a list of task generators we are interested in
tgt_list = []
for tgt in targets:
type = targets[tgt]
if not type in ['SUBSYSTEM', 'MODULE', 'BINARY', 'LIBRARY', 'ASN1', 'PYTHON']:
continue
t = bld.name_to_obj(tgt, bld.env)
if t is None:
print "Target %s of type %s has no task generator" % (tgt, type)
raise
tgt_list.append(t)
add_samba_attributes(bld, tgt_list)
if load_samba_deps(bld, tgt_list):
return
print "Checking project rules ..."
debug('deps: project rules checking started')
expand_subsystem_deps(bld)
build_direct_deps(bld, tgt_list)
break_dependency_loops(bld, tgt_list)
calculate_final_deps(bld, tgt_list, loops)
# run the various attribute generators
for f in [ build_dependencies, build_includes, add_init_functions ]:
debug('deps: project rules checking %s', f)
for t in tgt_list: f(t)
debug('deps: project rules stage1 completed')
#check_orpaned_targets(bld, tgt_list)
if not check_duplicate_sources(bld, tgt_list):
print "Duplicate sources present - aborting"
sys.exit(1)
show_final_deps(bld, tgt_list)
debug('deps: project rules checking completed - %u targets checked',
len(tgt_list))
save_samba_deps(bld, tgt_list)
print "Project rules pass"
def CHECK_PROJECT_RULES(bld):
'''enable checking of project targets for sanity'''
if bld.env.added_project_rules:
return
bld.env.added_project_rules = True
bld.add_pre_fun(check_project_rules)
Build.BuildContext.CHECK_PROJECT_RULES = CHECK_PROJECT_RULES
|