summaryrefslogtreecommitdiff
path: root/buildtools/wafsamba/samba_wildcard.py
blob: 75ab5defcdca1caf26edce3b42cec4c6180680f6 (plain)
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
#! /usr/bin/env python

# based on playground/evil in the waf svn tree

import os, datetime
import Scripting, Utils, Options, Logs, Environment, fnmatch
from Constants import *
from samba_utils import *

def run_task(t, k):
	'''run a single build task'''
	ret = t.run()
	if ret:
		raise Utils.WafError("Failed to build %s: %u" % (k, ret))


def run_named_build_task(cmd):
	'''run a named build task, matching the cmd name using fnmatch
	wildcards against inputs and outputs of all build tasks'''
	bld = fake_build_environment(info=False)
	found = False
	cwd_node = bld.root.find_dir(os.getcwd())
	top_node = bld.root.find_dir(bld.srcnode.abspath())

	cmd = os.path.normpath(cmd)

	# cope with builds of bin/*/*
	if os.path.islink(cmd):
		cmd = os_path_relpath(os.readlink(cmd), os.getcwd())

	if cmd[0:12] == "bin/default/":
		cmd = cmd[12:]

	for g in bld.task_manager.groups:
		for attr in ['outputs', 'inputs']:
			for t in g.tasks:
				s = getattr(t, attr, [])
				for k in s:
					relpath1 = k.relpath_gen(cwd_node)
					relpath2 = k.relpath_gen(top_node)
					if (fnmatch.fnmatch(relpath1, cmd) or
					    fnmatch.fnmatch(relpath2, cmd)):
						t.position = [0,0]
						print(t.display())
						run_task(t, k)
						found = True


	if not found:
		raise Utils.WafError("Unable to find build target matching %s" % cmd)


def rewrite_compile_targets():
	'''cope with the bin/ form of compile target'''
	if not Options.options.compile_targets:
		return

	bld = fake_build_environment(info=False)
	targets = LOCAL_CACHE(bld, 'TARGET_TYPE')
	tlist = []

	for t in Options.options.compile_targets.split(','):
		if not os.path.islink(t):
			tlist.append(t)
			continue
		link = os.readlink(t)
		list = link.split('/')
		for name in [list[-1], '/'.join(list[-2:])]:
			if name in targets:
				tlist.append(name)
				continue
	Options.options.compile_targets = ",".join(tlist)



def wildcard_main(missing_cmd_fn):
	'''this replaces main from Scripting, allowing us to override the
	   behaviour for unknown commands

	   If a unknown command is found, then missing_cmd_fn() is called with
	   the name of the requested command
	   '''
	Scripting.commands = Options.arg_line[:]

	# rewrite the compile targets to cope with the bin/xx form
	rewrite_compile_targets()

	while Scripting.commands:
		x = Scripting.commands.pop(0)

		ini = datetime.datetime.now()
		if x == 'configure':
			fun = Scripting.configure
		elif x == 'build':
			fun = Scripting.build
		else:
			fun = getattr(Utils.g_module, x, None)

		# this is the new addition on top of main from Scripting.py
		if not fun:
			missing_cmd_fn(x)
			break

		ctx = getattr(Utils.g_module, x + '_context', Utils.Context)()

		if x in ['init', 'shutdown', 'dist', 'distclean', 'distcheck']:
			try:
				fun(ctx)
			except TypeError:
				fun()
		else:
			fun(ctx)

		ela = ''
		if not Options.options.progress_bar:
			ela = ' (%s)' % Utils.get_elapsed_time(ini)

		if x != 'init' and x != 'shutdown':
			Logs.info('%r finished successfully%s' % (x, ela))

		if not Scripting.commands and x != 'shutdown':
			Scripting.commands.append('shutdown')




def fake_build_environment(info=True, flush=False):
	"""create all the tasks for the project, but do not run the build
	return the build context in use"""
	bld = getattr(Utils.g_module, 'build_context', Utils.Context)()
	bld = Scripting.check_configured(bld)

	Options.commands['install'] = False
	Options.commands['uninstall'] = False
	Options.is_install = False

	bld.is_install = 0 # False

	try:
		proj = Environment.Environment(Options.lockfile)
	except IOError:
		raise Utils.WafError("Project not configured (run 'waf configure' first)")

	bld.load_dirs(proj[SRCDIR], proj[BLDDIR])
	bld.load_envs()

	if info:
		Logs.info("Waf: Entering directory `%s'" % bld.bldnode.abspath())
	bld.add_subdirs([os.path.split(Utils.g_module.root_path)[0]])

	bld.pre_build()
	if flush:
		bld.flush()
	return bld