__init__.py.svn-base
上传用户:market2
上传日期:2018-11-18
资源大小:18786k
文件大小:14k
源码类别:

外挂编程

开发平台:

Windows_Unix

  1. """SCons.Script
  2. This file implements the main() function used by the scons script.
  3. Architecturally, this *is* the scons script, and will likely only be
  4. called from the external "scons" wrapper.  Consequently, anything here
  5. should not be, or be considered, part of the build engine.  If it's
  6. something that we expect other software to want to use, it should go in
  7. some other module.  If it's specific to the "scons" script invocation,
  8. it goes here.
  9. """
  10. #
  11. # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
  12. #
  13. # Permission is hereby granted, free of charge, to any person obtaining
  14. # a copy of this software and associated documentation files (the
  15. # "Software"), to deal in the Software without restriction, including
  16. # without limitation the rights to use, copy, modify, merge, publish,
  17. # distribute, sublicense, and/or sell copies of the Software, and to
  18. # permit persons to whom the Software is furnished to do so, subject to
  19. # the following conditions:
  20. #
  21. # The above copyright notice and this permission notice shall be included
  22. # in all copies or substantial portions of the Software.
  23. #
  24. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  25. # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  26. # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27. # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28. # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29. # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31. #
  32. __revision__ = "src/engine/SCons/Script/__init__.py 3057 2008/06/09 22:21:00 knight"
  33. import time
  34. start_time = time.time()
  35. import os
  36. import string
  37. import sys
  38. import UserList
  39. # Special chicken-and-egg handling of the "--debug=memoizer" flag:
  40. #
  41. # SCons.Memoize contains a metaclass implementation that affects how
  42. # the other classes are instantiated.  The Memoizer may add shim methods
  43. # to classes that have methods that cache computed values in order to
  44. # count and report the hits and misses.
  45. #
  46. # If we wait to enable the Memoization until after we've parsed the
  47. # command line options normally, it will be too late, because the Memoizer
  48. # will have already analyzed the classes that it's Memoizing and decided
  49. # to not add the shims.  So we use a special-case, up-front check for
  50. # the "--debug=memoizer" flag and enable Memoizer before we import any
  51. # of the other modules that use it.
  52. _args = sys.argv + string.split(os.environ.get('SCONSFLAGS', ''))
  53. if "--debug=memoizer" in _args:
  54.     import SCons.Memoize
  55.     import SCons.Warnings
  56.     try:
  57.         SCons.Memoize.EnableMemoization()
  58.     except SCons.Warnings.Warning:
  59.         # Some warning was thrown (inability to --debug=memoizer on
  60.         # Python 1.5.2 because it doesn't have metaclasses).  Arrange
  61.         # for it to be displayed or not after warnings are configured.
  62.         import Main
  63.         exc_type, exc_value, tb = sys.exc_info()
  64.         Main.delayed_warnings.append((exc_type, exc_value))
  65. del _args
  66. import SCons.Action
  67. import SCons.Builder
  68. import SCons.Environment
  69. import SCons.Node.FS
  70. import SCons.Options
  71. import SCons.Platform
  72. import SCons.Scanner
  73. import SCons.SConf
  74. import SCons.Subst
  75. import SCons.Tool
  76. import SCons.Util
  77. import SCons.Variables
  78. import SCons.Defaults
  79. import Main
  80. main                    = Main.main
  81. # The following are global class definitions and variables that used to
  82. # live directly in this module back before 0.96.90, when it contained
  83. # a lot of code.  Some SConscript files in widely-distributed packages
  84. # (Blender is the specific example) actually reached into SCons.Script
  85. # directly to use some of these.  Rather than break those SConscript
  86. # files, we're going to propagate these names into the SCons.Script
  87. # namespace here.
  88. #
  89. # Some of these are commented out because it's *really* unlikely anyone
  90. # used them, but we're going to leave the comment here to try to make
  91. # it obvious what to do if the situation arises.
  92. BuildTask               = Main.BuildTask
  93. CleanTask               = Main.CleanTask
  94. QuestionTask            = Main.QuestionTask
  95. #PrintHelp               = Main.PrintHelp
  96. #SConscriptSettableOptions = Main.SConscriptSettableOptions
  97. AddOption               = Main.AddOption
  98. GetOption               = Main.GetOption
  99. SetOption               = Main.SetOption
  100. Progress                = Main.Progress
  101. GetBuildFailures        = Main.GetBuildFailures
  102. #keep_going_on_error     = Main.keep_going_on_error
  103. #print_dtree             = Main.print_dtree
  104. #print_explanations      = Main.print_explanations
  105. #print_includes          = Main.print_includes
  106. #print_objects           = Main.print_objects
  107. #print_time              = Main.print_time
  108. #print_tree              = Main.print_tree
  109. #memory_stats            = Main.memory_stats
  110. #ignore_errors           = Main.ignore_errors
  111. #sconscript_time         = Main.sconscript_time
  112. #command_time            = Main.command_time
  113. #exit_status             = Main.exit_status
  114. #profiling               = Main.profiling
  115. #repositories            = Main.repositories
  116. #
  117. import SConscript
  118. _SConscript = SConscript
  119. call_stack              = _SConscript.call_stack
  120. #
  121. Action                  = SCons.Action.Action
  122. AddMethod               = SCons.Util.AddMethod
  123. AllowSubstExceptions    = SCons.Subst.SetAllowableExceptions
  124. Builder                 = SCons.Builder.Builder
  125. Configure               = _SConscript.Configure
  126. Environment             = SCons.Environment.Environment
  127. #OptParser               = SCons.SConsOptions.OptParser
  128. FindPathDirs            = SCons.Scanner.FindPathDirs
  129. Platform                = SCons.Platform.Platform
  130. Return                  = _SConscript.Return
  131. Scanner                 = SCons.Scanner.Base
  132. Tool                    = SCons.Tool.Tool
  133. WhereIs                 = SCons.Util.WhereIs
  134. #
  135. BoolVariable            = SCons.Variables.BoolVariable
  136. EnumVariable            = SCons.Variables.EnumVariable
  137. ListVariable            = SCons.Variables.ListVariable
  138. PackageVariable         = SCons.Variables.PackageVariable
  139. PathVariable            = SCons.Variables.PathVariable
  140. # Deprecated names that will go away some day.
  141. BoolOption              = SCons.Options.BoolOption
  142. EnumOption              = SCons.Options.EnumOption
  143. ListOption              = SCons.Options.ListOption
  144. PackageOption           = SCons.Options.PackageOption
  145. PathOption              = SCons.Options.PathOption
  146. # Action factories.
  147. Chmod                   = SCons.Defaults.Chmod
  148. Copy                    = SCons.Defaults.Copy
  149. Delete                  = SCons.Defaults.Delete
  150. Mkdir                   = SCons.Defaults.Mkdir
  151. Move                    = SCons.Defaults.Move
  152. Touch                   = SCons.Defaults.Touch
  153. # Pre-made, public scanners.
  154. CScanner                = SCons.Tool.CScanner
  155. DScanner                = SCons.Tool.DScanner
  156. DirScanner              = SCons.Defaults.DirScanner
  157. ProgramScanner          = SCons.Tool.ProgramScanner
  158. SourceFileScanner       = SCons.Tool.SourceFileScanner
  159. # Functions we might still convert to Environment methods.
  160. CScan                   = SCons.Defaults.CScan
  161. DefaultEnvironment      = SCons.Defaults.DefaultEnvironment
  162. # Other variables we provide.
  163. class TargetList(UserList.UserList):
  164.     def _do_nothing(self, *args, **kw):
  165.         pass
  166.     def _add_Default(self, list):
  167.         self.extend(list)
  168.     def _clear(self):
  169.         del self[:]
  170. ARGUMENTS               = {}
  171. ARGLIST                 = []
  172. BUILD_TARGETS           = TargetList()
  173. COMMAND_LINE_TARGETS    = []
  174. DEFAULT_TARGETS         = []
  175. # BUILD_TARGETS can be modified in the SConscript files.  If so, we
  176. # want to treat the modified BUILD_TARGETS list as if they specified
  177. # targets on the command line.  To do that, though, we need to know if
  178. # BUILD_TARGETS was modified through "official" APIs or by hand.  We do
  179. # this by updating two lists in parallel, the documented BUILD_TARGETS
  180. # list, above, and this internal _build_plus_default targets list which
  181. # should only have "official" API changes.  Then Script/Main.py can
  182. # compare these two afterwards to figure out if the user added their
  183. # own targets to BUILD_TARGETS.
  184. _build_plus_default = TargetList()
  185. def _Add_Arguments(alist):
  186.     for arg in alist:
  187.         a, b = string.split(arg, '=', 1)
  188.         ARGUMENTS[a] = b
  189.         ARGLIST.append((a, b))
  190. def _Add_Targets(tlist):
  191.     if tlist:
  192.         COMMAND_LINE_TARGETS.extend(tlist)
  193.         BUILD_TARGETS.extend(tlist)
  194.         BUILD_TARGETS._add_Default = BUILD_TARGETS._do_nothing
  195.         BUILD_TARGETS._clear = BUILD_TARGETS._do_nothing
  196.         _build_plus_default.extend(tlist)
  197.         _build_plus_default._add_Default = _build_plus_default._do_nothing
  198.         _build_plus_default._clear = _build_plus_default._do_nothing
  199. def _Set_Default_Targets_Has_Been_Called(d, fs):
  200.     return DEFAULT_TARGETS
  201. def _Set_Default_Targets_Has_Not_Been_Called(d, fs):
  202.     if d is None:
  203.         d = [fs.Dir('.')]
  204.     return d
  205. _Get_Default_Targets = _Set_Default_Targets_Has_Not_Been_Called
  206. def _Set_Default_Targets(env, tlist):
  207.     global DEFAULT_TARGETS
  208.     global _Get_Default_Targets
  209.     _Get_Default_Targets = _Set_Default_Targets_Has_Been_Called
  210.     for t in tlist:
  211.         if t is None:
  212.             # Delete the elements from the list in-place, don't
  213.             # reassign an empty list to DEFAULT_TARGETS, so that the
  214.             # variables will still point to the same object we point to.
  215.             del DEFAULT_TARGETS[:]
  216.             BUILD_TARGETS._clear()
  217.             _build_plus_default._clear()
  218.         elif isinstance(t, SCons.Node.Node):
  219.             DEFAULT_TARGETS.append(t)
  220.             BUILD_TARGETS._add_Default([t])
  221.             _build_plus_default._add_Default([t])
  222.         else:
  223.             nodes = env.arg2nodes(t, env.fs.Entry)
  224.             DEFAULT_TARGETS.extend(nodes)
  225.             BUILD_TARGETS._add_Default(nodes)
  226.             _build_plus_default._add_Default(nodes)
  227. #
  228. help_text = None
  229. def HelpFunction(text):
  230.     global help_text
  231.     if SCons.Script.help_text is None:
  232.         SCons.Script.help_text = text
  233.     else:
  234.         help_text = help_text + text
  235. #
  236. # Will be non-zero if we are reading an SConscript file.
  237. sconscript_reading = 0
  238. #
  239. def Variables(files=[], args=ARGUMENTS):
  240.     return SCons.Variables.Variables(files, args)
  241. def Options(files=[], args=ARGUMENTS):
  242.     return SCons.Options.Options(files, args)
  243. # The list of global functions to add to the SConscript name space
  244. # that end up calling corresponding methods or Builders in the
  245. # DefaultEnvironment().
  246. GlobalDefaultEnvironmentFunctions = [
  247.     # Methods from the SConsEnvironment class, above.
  248.     'Default',
  249.     'EnsurePythonVersion',
  250.     'EnsureSConsVersion',
  251.     'Exit',
  252.     'Export',
  253.     'GetLaunchDir',
  254.     'Help',
  255.     'Import',
  256.     #'SConscript', is handled separately, below.
  257.     'SConscriptChdir',
  258.     # Methods from the Environment.Base class.
  259.     'AddPostAction',
  260.     'AddPreAction',
  261.     'Alias',
  262.     'AlwaysBuild',
  263.     'BuildDir',
  264.     'CacheDir',
  265.     'Clean',
  266.     #The Command() method is handled separately, below.
  267.     'Decider',
  268.     'Depends',
  269.     'Dir',
  270.     'NoClean',
  271.     'NoCache',
  272.     'Entry',
  273.     'Execute',
  274.     'File',
  275.     'FindFile',
  276.     'FindInstalledFiles',
  277.     'FindSourceFiles',
  278.     'Flatten',
  279.     'GetBuildPath',
  280.     'Glob',
  281.     'Ignore',
  282.     'Install',
  283.     'InstallAs',
  284.     'Literal',
  285.     'Local',
  286.     'ParseDepends',
  287.     'Precious',
  288.     'Repository',
  289.     'Requires',
  290.     'SConsignFile',
  291.     'SideEffect',
  292.     'SourceCode',
  293.     'SourceSignatures',
  294.     'Split',
  295.     'Tag',
  296.     'TargetSignatures',
  297.     'Value',
  298.     'VariantDir',
  299. ]
  300. GlobalDefaultBuilders = [
  301.     # Supported builders.
  302.     'CFile',
  303.     'CXXFile',
  304.     'DVI',
  305.     'Jar',
  306.     'Java',
  307.     'JavaH',
  308.     'Library',
  309.     'M4',
  310.     'MSVSProject',
  311.     'Object',
  312.     'PCH',
  313.     'PDF',
  314.     'PostScript',
  315.     'Program',
  316.     'RES',
  317.     'RMIC',
  318.     'SharedLibrary',
  319.     'SharedObject',
  320.     'StaticLibrary',
  321.     'StaticObject',
  322.     'Tar',
  323.     'TypeLibrary',
  324.     'Zip',
  325.     'Package',
  326. ]
  327. for name in GlobalDefaultEnvironmentFunctions + GlobalDefaultBuilders:
  328.     exec "%s = _SConscript.DefaultEnvironmentCall(%s)" % (name, repr(name))
  329. del name
  330. # There are a handful of variables that used to live in the
  331. # Script/SConscript.py module that some SConscript files out there were
  332. # accessing directly as SCons.Script.SConscript.*.  The problem is that
  333. # "SConscript" in this namespace is no longer a module, it's a global
  334. # function call--or more precisely, an object that implements a global
  335. # function call through the default Environment.  Nevertheless, we can
  336. # maintain backwards compatibility for SConscripts that were reaching in
  337. # this way by hanging some attributes off the "SConscript" object here.
  338. SConscript = _SConscript.DefaultEnvironmentCall('SConscript')
  339. # Make SConscript look enough like the module it used to be so
  340. # that pychecker doesn't barf.
  341. SConscript.__name__ = 'SConscript'
  342. SConscript.Arguments = ARGUMENTS
  343. SConscript.ArgList = ARGLIST
  344. SConscript.BuildTargets = BUILD_TARGETS
  345. SConscript.CommandLineTargets = COMMAND_LINE_TARGETS
  346. SConscript.DefaultTargets = DEFAULT_TARGETS
  347. # The global Command() function must be handled differently than the
  348. # global functions for other construction environment methods because
  349. # we want people to be able to use Actions that must expand $TARGET
  350. # and $SOURCE later, when (and if) the Action is invoked to build
  351. # the target(s).  We do this with the subst=1 argument, which creates
  352. # a DefaultEnvironmentCall instance that wraps up a normal default
  353. # construction environment that performs variable substitution, not a
  354. # proxy that doesn't.
  355. #
  356. # There's a flaw here, though, because any other $-variables on a command
  357. # line will *also* be expanded, each to a null string, but that should
  358. # only be a problem in the unusual case where someone was passing a '$'
  359. # on a command line and *expected* the $ to get through to the shell
  360. # because they were calling Command() and not env.Command()...  This is
  361. # unlikely enough that we're going to leave this as is and cross that
  362. # bridge if someone actually comes to it.
  363. Command = _SConscript.DefaultEnvironmentCall('Command', subst=1)