1"""custom
2
3Custom builders and methods.
4
5"""
6
7#
8# Copyright 2008 VMware, Inc.
9# All Rights Reserved.
10#
11# Permission is hereby granted, free of charge, to any person obtaining a
12# copy of this software and associated documentation files (the
13# "Software"), to deal in the Software without restriction, including
14# without limitation the rights to use, copy, modify, merge, publish,
15# distribute, sub license, and/or sell copies of the Software, and to
16# permit persons to whom the Software is furnished to do so, subject to
17# the following conditions:
18#
19# The above copyright notice and this permission notice (including the
20# next paragraph) shall be included in all copies or substantial portions
21# of the Software.
22#
23# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
26# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
27# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
28# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
29# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30#
31
32
33import os.path
34import sys
35import subprocess
36import modulefinder
37
38import SCons.Action
39import SCons.Builder
40import SCons.Scanner
41
42import fixes
43
44import source_list
45
46# the get_implicit_deps() method changed between 2.4 and 2.5: now it expects
47# a callable that takes a scanner as argument and returns a path, rather than
48# a path directly. We want to support both, so we need to detect the SCons version,
49# for which no API is provided by SCons 8-P
50
51scons_version = tuple(map(int, SCons.__version__.split('.')))
52
53def quietCommandLines(env):
54    # Quiet command lines
55    # See also http://www.scons.org/wiki/HidingCommandLinesInOutput
56    env['ASCOMSTR'] = "  Assembling $SOURCE ..."
57    env['ASPPCOMSTR'] = "  Assembling $SOURCE ..."
58    env['CCCOMSTR'] = "  Compiling $SOURCE ..."
59    env['SHCCCOMSTR'] = "  Compiling $SOURCE ..."
60    env['CXXCOMSTR'] = "  Compiling $SOURCE ..."
61    env['SHCXXCOMSTR'] = "  Compiling $SOURCE ..."
62    env['ARCOMSTR'] = "  Archiving $TARGET ..."
63    env['RANLIBCOMSTR'] = "  Indexing $TARGET ..."
64    env['LINKCOMSTR'] = "  Linking $TARGET ..."
65    env['SHLINKCOMSTR'] = "  Linking $TARGET ..."
66    env['LDMODULECOMSTR'] = "  Linking $TARGET ..."
67    env['SWIGCOMSTR'] = "  Generating $TARGET ..."
68    env['LEXCOMSTR'] = "  Generating $TARGET ..."
69    env['YACCCOMSTR'] = "  Generating $TARGET ..."
70    env['CODEGENCOMSTR'] = "  Generating $TARGET ..."
71    env['INSTALLSTR'] = "  Installing $TARGET ..."
72
73
74def createConvenienceLibBuilder(env):
75    """This is a utility function that creates the ConvenienceLibrary
76    Builder in an Environment if it is not there already.
77
78    If it is already there, we return the existing one.
79
80    Based on the stock StaticLibrary and SharedLibrary builders.
81    """
82
83    try:
84        convenience_lib = env['BUILDERS']['ConvenienceLibrary']
85    except KeyError:
86        action_list = [ SCons.Action.Action("$ARCOM", "$ARCOMSTR") ]
87        if env.Detect('ranlib'):
88            ranlib_action = SCons.Action.Action("$RANLIBCOM", "$RANLIBCOMSTR")
89            action_list.append(ranlib_action)
90
91        convenience_lib = SCons.Builder.Builder(action = action_list,
92                                  emitter = '$LIBEMITTER',
93                                  prefix = '$LIBPREFIX',
94                                  suffix = '$LIBSUFFIX',
95                                  src_suffix = '$SHOBJSUFFIX',
96                                  src_builder = 'SharedObject')
97        env['BUILDERS']['ConvenienceLibrary'] = convenience_lib
98
99    return convenience_lib
100
101
102def python_scan(node, env, path):
103    # http://www.scons.org/doc/0.98.5/HTML/scons-user/c2781.html#AEN2789
104    # https://docs.python.org/2/library/modulefinder.html
105    contents = node.get_contents()
106
107    # Tell ModuleFinder to search dependencies in the script dir, and the glapi
108    # dirs
109    source_dir = node.get_dir().abspath
110    GLAPI = env.Dir('#src/mapi/glapi/gen').abspath
111    path = [source_dir, GLAPI] + sys.path
112
113    finder = modulefinder.ModuleFinder(path=path)
114    finder.run_script(node.abspath)
115    results = []
116    for name, mod in finder.modules.items():
117        if mod.__file__ is None:
118            continue
119        assert os.path.exists(mod.__file__)
120        results.append(env.File(mod.__file__))
121    return results
122
123python_scanner = SCons.Scanner.Scanner(function = python_scan, skeys = ['.py'])
124
125
126def code_generate(env, script, target, source, command):
127    """Method to simplify code generation via python scripts.
128
129    http://www.scons.org/wiki/UsingCodeGenerators
130    http://www.scons.org/doc/0.98.5/HTML/scons-user/c2768.html
131    """
132
133    # We're generating code using Python scripts, so we have to be
134    # careful with our scons elements.  This entry represents
135    # the generator file *in the source directory*.
136    script_src = env.File(script).srcnode()
137
138    # This command creates generated code *in the build directory*.
139    command = command.replace('$SCRIPT', script_src.path)
140    action = SCons.Action.Action(command, "$CODEGENCOMSTR")
141    code = env.Command(target, source, action)
142
143    # Explicitly mark that the generated code depends on the generator,
144    # and on implicitly imported python modules
145    path = (script_src.get_dir(),) if scons_version < (2, 5, 0) else lambda x: script_src
146    deps = [script_src]
147    deps += script_src.get_implicit_deps(env, python_scanner, path)
148    env.Depends(code, deps)
149
150    # Running the Python script causes .pyc files to be generated in the
151    # source directory.  When we clean up, they should go too. So add side
152    # effects for .pyc files
153    for dep in deps:
154        pyc = env.File(str(dep) + 'c')
155        env.SideEffect(pyc, code)
156
157    return code
158
159
160def createCodeGenerateMethod(env):
161    env.Append(SCANNERS = python_scanner)
162    env.AddMethod(code_generate, 'CodeGenerate')
163
164
165def _pkg_check_modules(env, name, modules):
166    '''Simple wrapper for pkg-config.'''
167
168    env['HAVE_' + name] = False
169
170    # For backwards compatability
171    env[name.lower()] = False
172
173    if env['platform'] == 'windows':
174        return
175
176    if not env.Detect('pkg-config'):
177        return
178
179    if subprocess.call(["pkg-config", "--exists", ' '.join(modules)]) != 0:
180        return
181
182    # Strip version expressions from modules
183    modules = [module.split(' ', 1)[0] for module in modules]
184
185    # Other flags may affect the compilation of unrelated targets, so store
186    # them with a prefix, (e.g., XXX_CFLAGS, XXX_LIBS, etc)
187    try:
188        flags = env.ParseFlags('!pkg-config --cflags --libs ' + ' '.join(modules))
189    except OSError:
190        return
191    prefix = name + '_'
192    for flag_name, flag_value in flags.items():
193        assert '_' not in flag_name
194        env[prefix + flag_name] = flag_value
195
196    env['HAVE_' + name] = True
197
198def pkg_check_modules(env, name, modules):
199
200    sys.stdout.write('Checking for %s (%s)...' % (name, ' '.join(modules)))
201    _pkg_check_modules(env, name, modules)
202    result = env['HAVE_' + name]
203    sys.stdout.write(' %s\n' % ['no', 'yes'][int(bool(result))])
204
205    # XXX: For backwards compatability
206    env[name.lower()] = result
207
208
209def pkg_use_modules(env, names):
210    '''Search for all environment flags that match NAME_FOO and append them to
211    the FOO environment variable.'''
212
213    names = env.Flatten(names)
214
215    for name in names:
216        prefix = name + '_'
217
218        if not 'HAVE_' + name in env:
219            raise Exception('Attempt to use unknown module %s' % name)
220
221        if not env['HAVE_' + name]:
222            raise Exception('Attempt to use unavailable module %s' % name)
223
224        flags = {}
225        for flag_name, flag_value in env.Dictionary().items():
226            if flag_name.startswith(prefix):
227                flag_name = flag_name[len(prefix):]
228                if '_' not in flag_name:
229                    flags[flag_name] = flag_value
230        if flags:
231            env.MergeFlags(flags)
232
233
234def createPkgConfigMethods(env):
235    env.AddMethod(pkg_check_modules, 'PkgCheckModules')
236    env.AddMethod(pkg_use_modules, 'PkgUseModules')
237
238
239def parse_source_list(env, filename, names=None):
240    # parse the source list file
241    parser = source_list.SourceListParser()
242    src = env.File(filename).srcnode()
243
244    cur_srcdir = env.Dir('.').srcnode().abspath
245    top_srcdir = env.Dir('#').abspath
246    top_builddir = os.path.join(top_srcdir, env['build_dir'])
247
248    # Normalize everything to / slashes
249    cur_srcdir = cur_srcdir.replace('\\', '/')
250    top_srcdir = top_srcdir.replace('\\', '/')
251    top_builddir = top_builddir.replace('\\', '/')
252
253    # Populate the symbol table of the Makefile parser.
254    parser.add_symbol('top_srcdir', top_srcdir)
255    parser.add_symbol('top_builddir', top_builddir)
256
257    sym_table = parser.parse(src.abspath)
258
259    if names:
260        if isinstance(names, basestring):
261            names = [names]
262
263        symbols = names
264    else:
265        symbols = list(sym_table.keys())
266
267    # convert the symbol table to source lists
268    src_lists = {}
269    for sym in symbols:
270        val = sym_table[sym]
271        srcs = []
272        for f in val.split():
273            if f:
274                # Process source paths
275                if f.startswith(top_builddir + '/src'):
276                    # Automake puts build output on a `src` subdirectory, but
277                    # SCons does not, so strip it here.
278                    f = top_builddir + f[len(top_builddir + '/src'):]
279                if f.startswith(cur_srcdir + '/'):
280                    # Prefer relative source paths, as absolute files tend to
281                    # cause duplicate actions.
282                    f = f[len(cur_srcdir + '/'):]
283                # do not include any headers
284                if f.endswith(tuple(['.h','.hpp','.inl'])):
285                    continue
286                srcs.append(f)
287
288        src_lists[sym] = srcs
289
290    # if names are given, concatenate the lists
291    if names:
292        srcs = []
293        for name in names:
294            srcs.extend(src_lists[name])
295
296        return srcs
297    else:
298        return src_lists
299
300def createParseSourceListMethod(env):
301    env.AddMethod(parse_source_list, 'ParseSourceList')
302
303
304def generate(env):
305    """Common environment generation code"""
306
307    verbose = env.get('verbose', False) or not env.get('quiet', True)
308    if not verbose:
309        quietCommandLines(env)
310
311    # Custom builders and methods
312    createConvenienceLibBuilder(env)
313    createCodeGenerateMethod(env)
314    createPkgConfigMethods(env)
315    createParseSourceListMethod(env)
316
317    # for debugging
318    #print env.Dump()
319
320
321def exists(env):
322    return 1
323