Home | History | Annotate | Download | only in scons 
      1 """custom
      2 
      3 Custom 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 
     33 import os.path
     34 import sys
     35 import subprocess
     36 import modulefinder
     37 
     38 import SCons.Action
     39 import SCons.Builder
     40 import SCons.Scanner
     41 
     42 import fixes
     43 
     44 import 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 
     51 scons_version = tuple(map(int, SCons.__version__.split('.')))
     52 
     53 def 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 
     74 def 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 
    102 def 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 
    123 python_scanner = SCons.Scanner.Scanner(function = python_scan, skeys = ['.py'])
    124 
    125 
    126 def 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 
    160 def createCodeGenerateMethod(env):
    161     env.Append(SCANNERS = python_scanner)
    162     env.AddMethod(code_generate, 'CodeGenerate')
    163 
    164 
    165 def _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 
    198 def 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 
    209 def 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 
    234 def createPkgConfigMethods(env):
    235     env.AddMethod(pkg_check_modules, 'PkgCheckModules')
    236     env.AddMethod(pkg_use_modules, 'PkgUseModules')
    237 
    238 
    239 def 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 
    300 def createParseSourceListMethod(env):
    301     env.AddMethod(parse_source_list, 'ParseSourceList')
    302 
    303 
    304 def 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 
    321 def exists(env):
    322     return 1
    323