Source Code for Module SCons.Defaults

  1  """SCons.Defaults 
  2   
  3  Builders and other things for the local site.  Here's where we'll 
  4  duplicate the functionality of autoconf until we move it into the 
  5  installation procedure or use something like qmconf. 
  6   
  7  The code that reads the registry to find MSVC components was borrowed 
  8  from distutils.msvccompiler. 
  9   
 10  """ 
 11   
 12  # 
 13  # Copyright (c) 2001 - 2015 The SCons Foundation 
 14  # 
 15  # Permission is hereby granted, free of charge, to any person obtaining 
 16  # a copy of this software and associated documentation files (the 
 17  # "Software"), to deal in the Software without restriction, including 
 18  # without limitation the rights to use, copy, modify, merge, publish, 
 19  # distribute, sublicense, and/or sell copies of the Software, and to 
 20  # permit persons to whom the Software is furnished to do so, subject to 
 21  # the following conditions: 
 22  # 
 23  # The above copyright notice and this permission notice shall be included 
 24  # in all copies or substantial portions of the Software. 
 25  # 
 26  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY 
 27  # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 
 28  # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 29  # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
 30  # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
 31  # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
 32  # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
 33  # 
 34  from __future__ import division 
 35   
 36  __revision__ = "src/engine/SCons/Defaults.py rel_2.4.1:3453:73fefd3ea0b0 2015/11/09 03:25:05 bdbaddog" 
 37   
 38   
 39  import os 
 40  import errno 
 41  import shutil 
 42  import stat 
 43  import time 
 44  import sys 
 45   
 46  import SCons.Action 
 47  import SCons.Builder 
 48  import SCons.CacheDir 
 49  import SCons.Environment 
 50  import SCons.PathList 
 51  import SCons.Subst 
 52  import SCons.Tool 
 53   
 54  # A placeholder for a default Environment (for fetching source files 
 55  # from source code management systems and the like).  This must be 
 56  # initialized later, after the top-level directory is set by the calling 
 57  # interface. 
 58  _default_env = None 
 59   
 60  # Lazily instantiate the default environment so the overhead of creating 
 61  # it doesn't apply when it's not needed. 
 62 -def _fetch_DefaultEnvironment(*args, **kw): 
 63      """ 
 64      Returns the already-created default construction environment. 
 65      """ 
 66      global _default_env 
 67      return _default_env 
 68   
 69 -def DefaultEnvironment(*args, **kw): 
 70      """ 
 71      Initial public entry point for creating the default construction 
 72      Environment. 
 73   
 74      After creating the environment, we overwrite our name 
 75      (DefaultEnvironment) with the _fetch_DefaultEnvironment() function, 
 76      which more efficiently returns the initialized default construction 
 77      environment without checking for its existence. 
 78   
 79      (This function still exists with its _default_check because someone 
 80      else (*cough* Script/__init__.py *cough*) may keep a reference 
 81      to this function.  So we can't use the fully functional idiom of 
 82      having the name originally be a something that *only* creates the 
 83      construction environment and then overwrites the name.) 
 84      """ 
 85      global _default_env 
 86      if not _default_env: 
 87          import SCons.Util 
 88          _default_env = SCons.Environment.Environment(*args, **kw) 
 89          if SCons.Util.md5: 
 90              _default_env.Decider('MD5') 
 91          else: 
 92              _default_env.Decider('timestamp-match') 
 93          global DefaultEnvironment 
 94          DefaultEnvironment = _fetch_DefaultEnvironment 
 95          _default_env._CacheDir_path = None 
 96      return _default_env 
 97   
 98  # Emitters for setting the shared attribute on object files, 
 99  # and an action for checking that all of the source files 
100  # going into a shared library are, in fact, shared. 
101 -def StaticObjectEmitter(target, source, env): 
102      for tgt in target: 
103          tgt.attributes.shared = None 
104      return (target, source) 
105   
106 -def SharedObjectEmitter(target, source, env): 
107      for tgt in target: 
108          tgt.attributes.shared = 1 
109      return (target, source) 
110   
111 -def SharedFlagChecker(source, target, env): 
112      same = env.subst('$STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME') 
113      if same == '0' or same == '' or same == 'False': 
114          for src in source: 
115              try: 
116                  shared = src.attributes.shared 
117              except AttributeError: 
118                  shared = None 
119              if not shared: 
120                  raise SCons.Errors.UserError("Source file: %s is static and is not compatible with shared target: %s" % (src, target[0])) 
121   
122  SharedCheck = SCons.Action.Action(SharedFlagChecker, None) 
123   
124  # Some people were using these variable name before we made 
125  # SourceFileScanner part of the public interface.  Don't break their 
126  # SConscript files until we've given them some fair warning and a 
127  # transition period. 
128  CScan = SCons.Tool.CScanner 
129  DScan = SCons.Tool.DScanner 
130  LaTeXScan = SCons.Tool.LaTeXScanner 
131  ObjSourceScan = SCons.Tool.SourceFileScanner 
132  ProgScan = SCons.Tool.ProgramScanner 
133   
134  # These aren't really tool scanners, so they don't quite belong with 
135  # the rest of those in Tool/__init__.py, but I'm not sure where else 
136  # they should go.  Leave them here for now. 
137  import SCons.Scanner.Dir 
138  DirScanner = SCons.Scanner.Dir.DirScanner() 
139  DirEntryScanner = SCons.Scanner.Dir.DirEntryScanner() 
140   
141  # Actions for common languages. 
142  CAction = SCons.Action.Action("$CCCOM", "$CCCOMSTR") 
143  ShCAction = SCons.Action.Action("$SHCCCOM", "$SHCCCOMSTR") 
144  CXXAction = SCons.Action.Action("$CXXCOM", "$CXXCOMSTR") 
145  ShCXXAction = SCons.Action.Action("$SHCXXCOM", "$SHCXXCOMSTR") 
146   
147  DAction = SCons.Action.Action("$DCOM", "$DCOMSTR") 
148  ShDAction = SCons.Action.Action("$SHDCOM", "$SHDCOMSTR") 
149   
150  ASAction = SCons.Action.Action("$ASCOM", "$ASCOMSTR") 
151  ASPPAction = SCons.Action.Action("$ASPPCOM", "$ASPPCOMSTR") 
152   
153  LinkAction = SCons.Action.Action("$LINKCOM", "$LINKCOMSTR") 
154  ShLinkAction = SCons.Action.Action("$SHLINKCOM", "$SHLINKCOMSTR") 
155   
156  LdModuleLinkAction = SCons.Action.Action("$LDMODULECOM", "$LDMODULECOMSTR") 
157   
158  # Common tasks that we allow users to perform in platform-independent 
159  # ways by creating ActionFactory instances. 
160  ActionFactory = SCons.Action.ActionFactory 
161   
162 -def get_paths_str(dest): 
163      # If dest is a list, we need to manually call str() on each element 
164      if SCons.Util.is_List(dest): 
165          elem_strs = [] 
166          for element in dest: 
167              elem_strs.append('"' + str(element) + '"') 
168          return '[' + ', '.join(elem_strs) + ']' 
169      else: 
170          return '"' + str(dest) + '"' 
171   
172 -def chmod_func(dest, mode): 
173      SCons.Node.FS.invalidate_node_memos(dest) 
174      if not SCons.Util.is_List(dest): 
175          dest = [dest] 
176      for element in dest: 
177          os.chmod(str(element), mode) 
178   
179 -def chmod_strfunc(dest, mode): 
180      return 'Chmod(%s, 0%o)' % (get_paths_str(dest), mode) 
181   
182  Chmod = ActionFactory(chmod_func, chmod_strfunc) 
183   
184 -def copy_func(dest, src, symlinks=True): 
185      """ 
186      If symlinks (is true), then a symbolic link will be 
187      shallow copied and recreated as a symbolic link; otherwise, copying 
188      a symbolic link will be equivalent to copying the symbolic link's 
189      final target regardless of symbolic link depth. 
190      """ 
191   
192      dest = str(dest) 
193      src = str(src) 
194   
195      SCons.Node.FS.invalidate_node_memos(dest) 
196      if SCons.Util.is_List(src) and os.path.isdir(dest): 
197          for file in src: 
198              shutil.copy2(file, dest) 
199          return 0 
200      elif os.path.islink(src): 
201          if symlinks: 
202              return os.symlink(os.readlink(src), dest) 
203          else: 
204              return copy_func(dest, os.path.realpath(src)) 
205      elif os.path.isfile(src): 
206          return shutil.copy2(src, dest) 
207      else: 
208          return shutil.copytree(src, dest, symlinks) 
209   
210  Copy = ActionFactory( 
211      copy_func, 
212      lambda dest, src, symlinks=True: 'Copy("%s", "%s")' % (dest, src) 
213  ) 
214   
215 -def delete_func(dest, must_exist=0): 
216      SCons.Node.FS.invalidate_node_memos(dest) 
217      if not SCons.Util.is_List(dest): 
218          dest = [dest] 
219      for entry in dest: 
220          entry = str(entry) 
221          # os.path.exists returns False with broken links that exist 
222          entry_exists = os.path.exists(entry) or os.path.islink(entry) 
223          if not entry_exists and not must_exist: 
224              continue 
225          # os.path.isdir returns True when entry is a link to a dir 
226          if os.path.isdir(entry) and not os.path.islink(entry): 
227              shutil.rmtree(entry, 1) 
228              continue 
229          os.unlink(entry) 
230   
231 -def delete_strfunc(dest, must_exist=0): 
232      return 'Delete(%s)' % get_paths_str(dest) 
233   
234  Delete = ActionFactory(delete_func, delete_strfunc) 
235   
236 -def mkdir_func(dest): 
237      SCons.Node.FS.invalidate_node_memos(dest) 
238      if not SCons.Util.is_List(dest): 
239          dest = [dest] 
240      for entry in dest: 
241          try: 
242              os.makedirs(str(entry)) 
243          except os.error, e: 
244              p = str(entry) 
245              if (e.args[0] == errno.EEXIST or 
246                      (sys.platform=='win32' and e.args[0]==183)) \ 
247                      and os.path.isdir(str(entry)): 
248                  pass            # not an error if already exists 
249              else: 
250                  raise 
251   
252  Mkdir = ActionFactory(mkdir_func, 
253                        lambda dir: 'Mkdir(%s)' % get_paths_str(dir)) 
254   
255 -def move_func(dest, src): 
256      SCons.Node.FS.invalidate_node_memos(dest) 
257      SCons.Node.FS.invalidate_node_memos(src) 
258      shutil.move(src, dest) 
259   
260  Move = ActionFactory(move_func, 
261                       lambda dest, src: 'Move("%s", "%s")' % (dest, src), 
262                       convert=str) 
263   
264 -def touch_func(dest): 
265      SCons.Node.FS.invalidate_node_memos(dest) 
266      if not SCons.Util.is_List(dest): 
267          dest = [dest] 
268      for file in dest: 
269          file = str(file) 
270          mtime = int(time.time()) 
271          if os.path.exists(file): 
272              atime = os.path.getatime(file) 
273          else: 
274              open(file, 'w') 
275              atime = mtime 
276          os.utime(file, (atime, mtime)) 
277   
278  Touch = ActionFactory(touch_func, 
279                        lambda file: 'Touch(%s)' % get_paths_str(file)) 
280   
281  # Internal utility functions 
282   
283 -def _concat(prefix, list, suffix, env, f=lambda x: x, target=None, source=None): 
284      """ 
285      Creates a new list from 'list' by first interpolating each element 
286      in the list using the 'env' dictionary and then calling f on the 
287      list, and finally calling _concat_ixes to concatenate 'prefix' and 
288      'suffix' onto each element of the list. 
289      """ 
290      if not list: 
291          return list 
292   
293      l = f(SCons.PathList.PathList(list).subst_path(env, target, source)) 
294      if l is not None: 
295          list = l 
296   
297      return _concat_ixes(prefix, list, suffix, env) 
298   
299 -def _concat_ixes(prefix, list, suffix, env): 
300      """ 
301      Creates a new list from 'list' by concatenating the 'prefix' and 
302      'suffix' arguments onto each element of the list.  A trailing space 
303      on 'prefix' or leading space on 'suffix' will cause them to be put 
304      into separate list elements rather than being concatenated. 
305      """ 
306   
307      result = [] 
308   
309      # ensure that prefix and suffix are strings 
310      prefix = str(env.subst(prefix, SCons.Subst.SUBST_RAW)) 
311      suffix = str(env.subst(suffix, SCons.Subst.SUBST_RAW)) 
312   
313      for x in list: 
314          if isinstance(x, SCons.Node.FS.File): 
315              result.append(x) 
316              continue 
317          x = str(x) 
318          if x: 
319   
320              if prefix: 
321                  if prefix[-1] == ' ': 
322                      result.append(prefix[:-1]) 
323                  elif x[:len(prefix)] != prefix: 
324                      x = prefix + x 
325   
326              result.append(x) 
327   
328              if suffix: 
329                  if suffix[0] == ' ': 
330                      result.append(suffix[1:]) 
331                  elif x[-len(suffix):] != suffix: 
332                      result[-1] = result[-1]+suffix 
333   
334      return result 
335   
336 -def _stripixes(prefix, itms, suffix, stripprefixes, stripsuffixes, env, c=None): 
337      """ 
338      This is a wrapper around _concat()/_concat_ixes() that checks for 
339      the existence of prefixes or suffixes on list items and strips them 
340      where it finds them.  This is used by tools (like the GNU linker) 
341      that need to turn something like 'libfoo.a' into '-lfoo'. 
342      """ 
343   
344      if not itms: 
345          return itms 
346   
347      if not callable(c): 
348          env_c = env['_concat'] 
349          if env_c != _concat and callable(env_c): 
350              # There's a custom _concat() method in the construction 
351              # environment, and we've allowed people to set that in 
352              # the past (see test/custom-concat.py), so preserve the 
353              # backwards compatibility. 
354              c = env_c 
355          else: 
356              c = _concat_ixes 
357   
358      stripprefixes = list(map(env.subst, SCons.Util.flatten(stripprefixes))) 
359      stripsuffixes = list(map(env.subst, SCons.Util.flatten(stripsuffixes))) 
360   
361      stripped = [] 
362      for l in SCons.PathList.PathList(itms).subst_path(env, None, None): 
363          if isinstance(l, SCons.Node.FS.File): 
364              stripped.append(l) 
365              continue 
366   
367          if not SCons.Util.is_String(l): 
368              l = str(l) 
369   
370          for stripprefix in stripprefixes: 
371              lsp = len(stripprefix) 
372              if l[:lsp] == stripprefix: 
373                  l = l[lsp:] 
374                  # Do not strip more than one prefix 
375                  break 
376   
377          for stripsuffix in stripsuffixes: 
378              lss = len(stripsuffix) 
379              if l[-lss:] == stripsuffix: 
380                  l = l[:-lss] 
381                  # Do not strip more than one suffix 
382                  break 
383   
384          stripped.append(l) 
385   
386      return c(prefix, stripped, suffix, env) 
387   
388 -def processDefines(defs): 
389      """process defines, resolving strings, lists, dictionaries, into a list of 
390      strings 
391      """ 
392      if SCons.Util.is_List(defs): 
393          l = [] 
394          for d in defs: 
395              if d is None: 
396                  continue 
397              elif SCons.Util.is_List(d) or isinstance(d, tuple): 
398                  if len(d) >= 2: 
399                      l.append(str(d[0]) + '=' + str(d[1])) 
400                  else: 
401                      l.append(str(d[0])) 
402              elif SCons.Util.is_Dict(d): 
403                  for macro,value in d.iteritems(): 
404                      if value is not None: 
405                          l.append(str(macro) + '=' + str(value)) 
406                      else: 
407                          l.append(str(macro)) 
408              elif SCons.Util.is_String(d): 
409                  l.append(str(d)) 
410              else: 
411                  raise SCons.Errors.UserError("DEFINE %s is not a list, dict, string or None."%repr(d)) 
412      elif SCons.Util.is_Dict(defs): 
413          # The items in a dictionary are stored in random order, but 
414          # if the order of the command-line options changes from 
415          # invocation to invocation, then the signature of the command 
416          # line will change and we'll get random unnecessary rebuilds. 
417          # Consequently, we have to sort the keys to ensure a 
418          # consistent order... 
419          l = [] 
420          for k,v in sorted(defs.items()): 
421              if v is None: 
422                  l.append(str(k)) 
423              else: 
424                  l.append(str(k) + '=' + str(v)) 
425      else: 
426          l = [str(defs)] 
427      return l 
428   
429 -def _defines(prefix, defs, suffix, env, c=_concat_ixes): 
430      """A wrapper around _concat_ixes that turns a list or string 
431      into a list of C preprocessor command-line definitions. 
432      """ 
433   
434      return c(prefix, env.subst_path(processDefines(defs)), suffix, env) 
435   
436 -class NullCmdGenerator(object): 
437      """This is a callable class that can be used in place of other 
438      command generators if you don't want them to do anything. 
439   
440      The __call__ method for this class simply returns the thing 
441      you instantiated it with. 
442   
443      Example usage: 
444      env["DO_NOTHING"] = NullCmdGenerator 
445      env["LINKCOM"] = "${DO_NOTHING('$LINK $SOURCES $TARGET')}" 
446      """ 
447   
448 -    def __init__(self, cmd): 
449          self.cmd = cmd 
450   
451 -    def __call__(self, target, source, env, for_signature=None): 
452          return self.cmd 
453   
454 -class Variable_Method_Caller(object): 
455      """A class for finding a construction variable on the stack and 
456      calling one of its methods. 
457   
458      We use this to support "construction variables" in our string 
459      eval()s that actually stand in for methods--specifically, use 
460      of "RDirs" in call to _concat that should actually execute the 
461      "TARGET.RDirs" method.  (We used to support this by creating a little 
462      "build dictionary" that mapped RDirs to the method, but this got in 
463      the way of Memoizing construction environments, because we had to 
464      create new environment objects to hold the variables.) 
465      """ 
466 -    def __init__(self, variable, method): 
467          self.variable = variable 
468          self.method = method 
469 -    def __call__(self, *args, **kw): 
470          try: 1//0 
471          except ZeroDivisionError: 
472              # Don't start iterating with the current stack-frame to 
473              # prevent creating reference cycles (f_back is safe). 
474              frame = sys.exc_info()[2].tb_frame.f_back 
475          variable = self.variable 
476          while frame: 
477              if variable in frame.f_locals: 
478                  v = frame.f_locals[variable] 
479                  if v: 
480                      method = getattr(v, self.method) 
481                      return method(*args, **kw) 
482              frame = frame.f_back 
483          return None 
484   
485  # if env[version_var] id defined, returns env[flags_var], otherwise returns None 
486 -def __libversionflags(env, version_var, flags_var): 
487      try: 
488          if env[version_var]: 
489              return env[flags_var] 
490      except KeyError: 
491          pass 
492      return None 
493   
494  ConstructionEnvironment = { 
495      'BUILDERS'      : {}, 
496      'SCANNERS'      : [], 
497      'CONFIGUREDIR'  : '#/.sconf_temp', 
498      'CONFIGURELOG'  : '#/config.log', 
499      'CPPSUFFIXES'   : SCons.Tool.CSuffixes, 
500      'DSUFFIXES'     : SCons.Tool.DSuffixes, 
501      'ENV'           : {}, 
502      'IDLSUFFIXES'   : SCons.Tool.IDLSuffixes, 
503  #    'LATEXSUFFIXES' : SCons.Tool.LaTeXSuffixes, # moved to the TeX tools generate functions 
504      '_concat'       : _concat, 
505      '_defines'      : _defines, 
506      '_stripixes'    : _stripixes, 
507      '_LIBFLAGS'     : '${_concat(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, __env__)}', 
508      '_LIBDIRFLAGS'  : '$( ${_concat(LIBDIRPREFIX, LIBPATH, LIBDIRSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)', 
509      '_CPPINCFLAGS'  : '$( ${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)', 
510      '_CPPDEFFLAGS'  : '${_defines(CPPDEFPREFIX, CPPDEFINES, CPPDEFSUFFIX, __env__)}', 
511   
512      '__libversionflags'      : __libversionflags, 
513      '__SHLIBVERSIONFLAGS'    : '${__libversionflags(__env__,"SHLIBVERSION","_SHLIBVERSIONFLAGS")}', 
514      '__LDMODULEVERSIONFLAGS' : '${__libversionflags(__env__,"LDMODULEVERSION","_LDMODULEVERSIONFLAGS")}', 
515      '__DSHLIBVERSIONFLAGS'   : '${__libversionflags(__env__,"DSHLIBVERSION","_DSHLIBVERSIONFLAGS")}', 
516   
517      'TEMPFILE'      : NullCmdGenerator, 
518      'Dir'           : Variable_Method_Caller('TARGET', 'Dir'), 
519      'Dirs'          : Variable_Method_Caller('TARGET', 'Dirs'), 
520      'File'          : Variable_Method_Caller('TARGET', 'File'), 
521      'RDirs'         : Variable_Method_Caller('TARGET', 'RDirs'), 
522  } 
523   
524  # Local Variables: 
525  # tab-width:4 
526  # indent-tabs-mode:nil 
527  # End: 
528  # vim: set expandtab tabstop=4 shiftwidth=4: 
529