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, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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   
 35  __revision__ = "src/engine/SCons/Defaults.py 3765 2008/11/04 08:12:16 scons" 
 36   
 37   
 38   
 39  import os 
 40  import os.path 
 41  import shutil 
 42  import stat 
 43  import string 
 44  import time 
 45  import types 
 46  import sys 
 47   
 48  import SCons.Action 
 49  import SCons.Builder 
 50  import SCons.CacheDir 
 51  import SCons.Environment 
 52  import SCons.PathList 
 53  import SCons.Subst 
 54  import SCons.Tool 
 55   
 56  # A placeholder for a default Environment (for fetching source files 
 57  # from source code management systems and the like).  This must be 
 58  # initialized later, after the top-level directory is set by the calling 
 59  # interface. 
 60  _default_env = None 
 61   
 62  # Lazily instantiate the default environment so the overhead of creating 
 63  # it doesn't apply when it's not needed. 
 64 -def _fetch_DefaultEnvironment(*args, **kw): 
 65      """ 
 66      Returns the already-created default construction environment. 
 67      """ 
 68      global _default_env 
 69      return _default_env 
 70   
 71 -def DefaultEnvironment(*args, **kw): 
 72      """ 
 73      Initial public entry point for creating the default construction 
 74      Environment. 
 75   
 76      After creating the environment, we overwrite our name 
 77      (DefaultEnvironment) with the _fetch_DefaultEnvironment() function, 
 78      which more efficiently returns the initialized default construction 
 79      environment without checking for its existence. 
 80   
 81      (This function still exists with its _default_check because someone 
 82      else (*cough* Script/__init__.py *cough*) may keep a reference 
 83      to this function.  So we can't use the fully functional idiom of 
 84      having the name originally be a something that *only* creates the 
 85      construction environment and then overwrites the name.) 
 86      """ 
 87      global _default_env 
 88      if not _default_env: 
 89          import SCons.Util 
 90          _default_env = apply(SCons.Environment.Environment, args, kw) 
 91          if SCons.Util.md5: 
 92              _default_env.Decider('MD5') 
 93          else: 
 94              _default_env.Decider('timestamp-match') 
 95          global DefaultEnvironment 
 96          DefaultEnvironment = _fetch_DefaultEnvironment 
 97          _default_env._CacheDir_path = None 
 98      return _default_env 
 99   
100  # Emitters for setting the shared attribute on object files, 
101  # and an action for checking that all of the source files 
102  # going into a shared library are, in fact, shared. 
103 -def StaticObjectEmitter(target, source, env): 
104      for tgt in target: 
105          tgt.attributes.shared = None 
106      return (target, source) 
107   
108 -def SharedObjectEmitter(target, source, env): 
109      for tgt in target: 
110          tgt.attributes.shared = 1 
111      return (target, source) 
112   
113 -def SharedFlagChecker(source, target, env): 
114      same = env.subst('$STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME') 
115      if same == '0' or same == '' or same == 'False': 
116          for src in source: 
117              try: 
118                  shared = src.attributes.shared 
119              except AttributeError: 
120                  shared = None 
121              if not shared: 
122                  raise SCons.Errors.UserError, "Source file: %s is static and is not compatible with shared target: %s" % (src, target[0]) 
123   
124  SharedCheck = SCons.Action.Action(SharedFlagChecker, None) 
125   
126  # Some people were using these variable name before we made 
127  # SourceFileScanner part of the public interface.  Don't break their 
128  # SConscript files until we've given them some fair warning and a 
129  # transition period. 
130  CScan = SCons.Tool.CScanner 
131  DScan = SCons.Tool.DScanner 
132  LaTeXScan = SCons.Tool.LaTeXScanner 
133  ObjSourceScan = SCons.Tool.SourceFileScanner 
134  ProgScan = SCons.Tool.ProgramScanner 
135   
136  # These aren't really tool scanners, so they don't quite belong with 
137  # the rest of those in Tool/__init__.py, but I'm not sure where else 
138  # they should go.  Leave them here for now. 
139  import SCons.Scanner.Dir 
140  DirScanner = SCons.Scanner.Dir.DirScanner() 
141  DirEntryScanner = SCons.Scanner.Dir.DirEntryScanner() 
142   
143  # Actions for common languages. 
144  CAction = SCons.Action.Action("$CCCOM", "$CCCOMSTR") 
145  ShCAction = SCons.Action.Action("$SHCCCOM", "$SHCCCOMSTR") 
146  CXXAction = SCons.Action.Action("$CXXCOM", "$CXXCOMSTR") 
147  ShCXXAction = SCons.Action.Action("$SHCXXCOM", "$SHCXXCOMSTR") 
148   
149  ASAction = SCons.Action.Action("$ASCOM", "$ASCOMSTR") 
150  ASPPAction = SCons.Action.Action("$ASPPCOM", "$ASPPCOMSTR") 
151   
152  LinkAction = SCons.Action.Action("$LINKCOM", "$LINKCOMSTR") 
153  ShLinkAction = SCons.Action.Action("$SHLINKCOM", "$SHLINKCOMSTR") 
154   
155  LdModuleLinkAction = SCons.Action.Action("$LDMODULECOM", "$LDMODULECOMSTR") 
156   
157  # Common tasks that we allow users to perform in platform-independent 
158  # ways by creating ActionFactory instances. 
159  ActionFactory = SCons.Action.ActionFactory 
160   
161 -def get_paths_str(dest): 
162      # If dest is a list, we need to manually call str() on each element 
163      if SCons.Util.is_List(dest): 
164          elem_strs = [] 
165          for element in dest: 
166              elem_strs.append('"' + str(element) + '"') 
167          return '[' + string.join(elem_strs, ', ') + ']' 
168      else: 
169          return '"' + str(dest) + '"' 
170   
171 -def chmod_func(dest, mode): 
172      SCons.Node.FS.invalidate_node_memos(dest) 
173      if not SCons.Util.is_List(dest): 
174          dest = [dest] 
175      for element in dest: 
176          os.chmod(str(element), mode) 
177   
178 -def chmod_strfunc(dest, mode): 
179      return 'Chmod(%s, 0%o)' % (get_paths_str(dest), mode) 
180   
181  Chmod = ActionFactory(chmod_func, chmod_strfunc) 
182   
183 -def copy_func(dest, src): 
184      SCons.Node.FS.invalidate_node_memos(dest) 
185      if SCons.Util.is_List(src) and os.path.isdir(dest): 
186          for file in src: 
187              shutil.copy2(file, dest) 
188          return 0 
189      elif os.path.isfile(src): 
190          return shutil.copy2(src, dest) 
191      else: 
192          return shutil.copytree(src, dest, 1) 
193   
194  Copy = ActionFactory(copy_func, 
195                       lambda dest, src: 'Copy("%s", "%s")' % (dest, src), 
196                       convert=str) 
197   
198 -def delete_func(dest, must_exist=0): 
199      SCons.Node.FS.invalidate_node_memos(dest) 
200      if not SCons.Util.is_List(dest): 
201          dest = [dest] 
202      for entry in dest: 
203          entry = str(entry) 
204          if not must_exist and not os.path.exists(entry): 
205              continue 
206          if not os.path.exists(entry) or os.path.isfile(entry): 
207              os.unlink(entry) 
208              continue 
209          else: 
210              shutil.rmtree(entry, 1) 
211              continue 
212   
213 -def delete_strfunc(dest, must_exist=0): 
214      return 'Delete(%s)' % get_paths_str(dest) 
215   
216  Delete = ActionFactory(delete_func, delete_strfunc) 
217   
218 -def mkdir_func(dest): 
219      SCons.Node.FS.invalidate_node_memos(dest) 
220      if not SCons.Util.is_List(dest): 
221          dest = [dest] 
222      for entry in dest: 
223          os.makedirs(str(entry)) 
224   
225  Mkdir = ActionFactory(mkdir_func, 
226                        lambda dir: 'Mkdir(%s)' % get_paths_str(dir)) 
227   
228 -def move_func(dest, src): 
229      SCons.Node.FS.invalidate_node_memos(dest) 
230      SCons.Node.FS.invalidate_node_memos(src) 
231      os.rename(src, dest) 
232   
233  Move = ActionFactory(move_func, 
234                       lambda dest, src: 'Move("%s", "%s")' % (dest, src), 
235                       convert=str) 
236   
237 -def touch_func(dest): 
238      SCons.Node.FS.invalidate_node_memos(dest) 
239      if not SCons.Util.is_List(dest): 
240          dest = [dest] 
241      for file in dest: 
242          file = str(file) 
243          mtime = int(time.time()) 
244          if os.path.exists(file): 
245              atime = os.path.getatime(file) 
246          else: 
247              open(file, 'w') 
248              atime = mtime 
249          os.utime(file, (atime, mtime)) 
250   
251  Touch = ActionFactory(touch_func, 
252                        lambda file: 'Touch(%s)' % get_paths_str(file)) 
253   
254  # Internal utility functions 
255   
256 -def _concat(prefix, list, suffix, env, f=lambda x: x, target=None, source=None): 
257      """ 
258      Creates a new list from 'list' by first interpolating each element 
259      in the list using the 'env' dictionary and then calling f on the 
260      list, and finally calling _concat_ixes to concatenate 'prefix' and 
261      'suffix' onto each element of the list. 
262      """ 
263      if not list: 
264          return list 
265   
266      l = f(SCons.PathList.PathList(list).subst_path(env, target, source)) 
267      if not l is None: 
268          list = l 
269   
270      return _concat_ixes(prefix, list, suffix, env) 
271   
272 -def _concat_ixes(prefix, list, suffix, env): 
273      """ 
274      Creates a new list from 'list' by concatenating the 'prefix' and 
275      'suffix' arguments onto each element of the list.  A trailing space 
276      on 'prefix' or leading space on 'suffix' will cause them to be put 
277      into separate list elements rather than being concatenated. 
278      """ 
279   
280      result = [] 
281   
282      # ensure that prefix and suffix are strings 
283      prefix = str(env.subst(prefix, SCons.Subst.SUBST_RAW)) 
284      suffix = str(env.subst(suffix, SCons.Subst.SUBST_RAW)) 
285   
286      for x in list: 
287          if isinstance(x, SCons.Node.FS.File): 
288              result.append(x) 
289              continue 
290          x = str(x) 
291          if x: 
292   
293              if prefix: 
294                  if prefix[-1] == ' ': 
295                      result.append(prefix[:-1]) 
296                  elif x[:len(prefix)] != prefix: 
297                      x = prefix + x 
298   
299              result.append(x) 
300   
301              if suffix: 
302                  if suffix[0] == ' ': 
303                      result.append(suffix[1:]) 
304                  elif x[-len(suffix):] != suffix: 
305                      result[-1] = result[-1]+suffix 
306   
307      return result 
308   
309 -def _stripixes(prefix, list, suffix, stripprefixes, stripsuffixes, env, c=None): 
310      """ 
311      This is a wrapper around _concat()/_concat_ixes() that checks for the 
312      existence of prefixes or suffixes on list elements and strips them 
313      where it finds them.  This is used by tools (like the GNU linker) 
314      that need to turn something like 'libfoo.a' into '-lfoo'. 
315      """ 
316       
317      if not list: