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

外挂编程

开发平台:

Windows_Unix

  1. """engine.SCons.Variables
  2. This file defines the Variables class that is used to add user-friendly
  3. customizable variables to an SCons build.
  4. """
  5. #
  6. # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
  7. #
  8. # Permission is hereby granted, free of charge, to any person obtaining
  9. # a copy of this software and associated documentation files (the
  10. # "Software"), to deal in the Software without restriction, including
  11. # without limitation the rights to use, copy, modify, merge, publish,
  12. # distribute, sublicense, and/or sell copies of the Software, and to
  13. # permit persons to whom the Software is furnished to do so, subject to
  14. # the following conditions:
  15. #
  16. # The above copyright notice and this permission notice shall be included
  17. # in all copies or substantial portions of the Software.
  18. #
  19. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  20. # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  21. # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22. # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  23. # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24. # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26. #
  27. __revision__ = "src/engine/SCons/Variables/__init__.py 3057 2008/06/09 22:21:00 knight"
  28. import SCons.compat
  29. import os.path
  30. import string
  31. import sys
  32. import SCons.Environment
  33. import SCons.Errors
  34. import SCons.Util
  35. import SCons.Warnings
  36. from BoolVariable import BoolVariable  # okay
  37. from EnumVariable import EnumVariable  # okay
  38. from ListVariable import ListVariable  # naja
  39. from PackageVariable import PackageVariable # naja
  40. from PathVariable import PathVariable # okay
  41. class Variables:
  42.     instance=None
  43.     """
  44.     Holds all the options, updates the environment with the variables,
  45.     and renders the help text.
  46.     """
  47.     def __init__(self, files=[], args={}, is_global=1):
  48.         """
  49.         files - [optional] List of option configuration files to load
  50.             (backward compatibility) If a single string is passed it is
  51.                                      automatically placed in a file list
  52.         """
  53.         self.options = []
  54.         self.args = args
  55.         if not SCons.Util.is_List(files):
  56.             if files:
  57.                 files = [ files ]
  58.             else:
  59.                 files = []
  60.         self.files = files
  61.         self.unknown = {}
  62.         # create the singleton instance
  63.         if is_global:
  64.             self=Variables.instance
  65.             if not Variables.instance:
  66.                 Variables.instance=self
  67.     def _do_add(self, key, help="", default=None, validator=None, converter=None):
  68.         class Variable:
  69.             pass
  70.         option = Variable()
  71.         # if we get a list or a tuple, we take the first element as the
  72.         # option key and store the remaining in aliases.
  73.         if SCons.Util.is_List(key) or SCons.Util.is_Tuple(key):
  74.           option.key     = key[0]
  75.           option.aliases = key[1:]
  76.         else:
  77.           option.key     = key
  78.           option.aliases = [ key ]
  79.         option.help = help
  80.         option.default = default
  81.         option.validator = validator
  82.         option.converter = converter
  83.         self.options.append(option)
  84.     def keys(self):
  85.         """
  86.         Returns the keywords for the options
  87.         """
  88.         return map(lambda o: o.key, self.options)
  89.     def Add(self, key, help="", default=None, validator=None, converter=None, **kw):
  90.         """
  91.         Add an option.
  92.         key - the name of the variable, or a list or tuple of arguments
  93.         help - optional help text for the options
  94.         default - optional default value
  95.         validator - optional function that is called to validate the option's value
  96.                     Called with (key, value, environment)
  97.         converter - optional function that is called to convert the option's value before
  98.                     putting it in the environment.
  99.         """
  100.         if SCons.Util.is_List(key) or type(key) == type(()):
  101.             apply(self._do_add, key)
  102.             return
  103.         if not SCons.Util.is_String(key) or 
  104.            not SCons.Environment.is_valid_construction_var(key):
  105.             raise SCons.Errors.UserError, "Illegal Variables.Add() key `%s'" % str(key)
  106.         self._do_add(key, help, default, validator, converter)
  107.     def AddVariables(self, *optlist):
  108.         """
  109.         Add a list of options.
  110.         Each list element is a tuple/list of arguments to be passed on
  111.         to the underlying method for adding options.
  112.         Example:
  113.           opt.AddVariables(
  114.             ('debug', '', 0),
  115.             ('CC', 'The C compiler'),
  116.             ('VALIDATE', 'An option for testing validation', 'notset',
  117.              validator, None),
  118.             )
  119.         """
  120.         for o in optlist:
  121.             apply(self._do_add, o)
  122.     def Update(self, env, args=None):
  123.         """
  124.         Update an environment with the option variables.
  125.         env - the environment to update.
  126.         """
  127.         values = {}
  128.         # first set the defaults:
  129.         for option in self.options:
  130.             if not option.default is None:
  131.                 values[option.key] = option.default
  132.         # next set the value specified in the options file
  133.         for filename in self.files:
  134.             if os.path.exists(filename):
  135.                 dir = os.path.split(os.path.abspath(filename))[0]
  136.                 if dir:
  137.                     sys.path.insert(0, dir)
  138.                 try:
  139.                     values['__name__'] = filename
  140.                     execfile(filename, {}, values)
  141.                 finally:
  142.                     if dir:
  143.                         del sys.path[0]
  144.                     del values['__name__']
  145.         # set the values specified on the command line
  146.         if args is None:
  147.             args = self.args
  148.         for arg, value in args.items():
  149.             added = False
  150.             for option in self.options:
  151.                 if arg in option.aliases + [ option.key ]:
  152.                     values[option.key] = value
  153.                     added = True
  154.             if not added:
  155.                 self.unknown[arg] = value
  156.         # put the variables in the environment:
  157.         # (don't copy over variables that are not declared as options)
  158.         for option in self.options:
  159.             try:
  160.                 env[option.key] = values[option.key]
  161.             except KeyError:
  162.                 pass
  163.         # Call the convert functions:
  164.         for option in self.options:
  165.             if option.converter and values.has_key(option.key):
  166.                 value = env.subst('${%s}'%option.key)
  167.                 try:
  168.                     try:
  169.                         env[option.key] = option.converter(value)
  170.                     except TypeError:
  171.                         env[option.key] = option.converter(value, env)
  172.                 except ValueError, x:
  173.                     raise SCons.Errors.UserError, 'Error converting option: %sn%s'%(option.key, x)
  174.         # Finally validate the values:
  175.         for option in self.options:
  176.             if option.validator and values.has_key(option.key):
  177.                 option.validator(option.key, env.subst('${%s}'%option.key), env)
  178.     def UnknownVariables(self):
  179.         """
  180.         Returns any options in the specified arguments lists that
  181.         were not known, declared options in this object.
  182.         """
  183.         return self.unknown
  184.     def Save(self, filename, env):
  185.         """
  186.         Saves all the options in the given file.  This file can
  187.         then be used to load the options next run.  This can be used
  188.         to create an option cache file.
  189.         filename - Name of the file to save into
  190.         env - the environment get the option values from
  191.         """
  192.         # Create the file and write out the header
  193.         try:
  194.             fh = open(filename, 'w')
  195.             try:
  196.                 # Make an assignment in the file for each option
  197.                 # within the environment that was assigned a value
  198.                 # other than the default.
  199.                 for option in self.options:
  200.                     try:
  201.                         value = env[option.key]
  202.                         try:
  203.                             prepare = value.prepare_to_store
  204.                         except AttributeError:
  205.                             try:
  206.                                 eval(repr(value))
  207.                             except KeyboardInterrupt:
  208.                                 raise
  209.                             except:
  210.                                 # Convert stuff that has a repr() that
  211.                                 # cannot be evaluated into a string
  212.                                 value = SCons.Util.to_String(value)
  213.                         else:
  214.                             value = prepare()
  215.                         defaultVal = env.subst(SCons.Util.to_String(option.default))
  216.                         if option.converter:
  217.                             defaultVal = option.converter(defaultVal)
  218.                         if str(env.subst('${%s}' % option.key)) != str(defaultVal):
  219.                             fh.write('%s = %sn' % (option.key, repr(value)))
  220.                     except KeyError:
  221.                         pass
  222.             finally:
  223.                 fh.close()
  224.         except IOError, x:
  225.             raise SCons.Errors.UserError, 'Error writing options to file: %sn%s' % (filename, x)
  226.     def GenerateHelpText(self, env, sort=None):
  227.         """
  228.         Generate the help text for the options.
  229.         env - an environment that is used to get the current values
  230.               of the options.
  231.         """
  232.         if sort:
  233.             options = self.options[:]
  234.             options.sort(lambda x,y,func=sort: func(x.key,y.key))
  235.         else:
  236.             options = self.options
  237.         def format(opt, self=self, env=env):
  238.             if env.has_key(opt.key):
  239.                 actual = env.subst('${%s}' % opt.key)
  240.             else:
  241.                 actual = None
  242.             return self.FormatVariableHelpText(env, opt.key, opt.help, opt.default, actual, opt.aliases)
  243.         lines = filter(None, map(format, options))
  244.         return string.join(lines, '')
  245.     format  = 'n%s: %sn    default: %sn    actual: %sn'
  246.     format_ = 'n%s: %sn    default: %sn    actual: %sn    aliases: %sn'
  247.     def FormatVariableHelpText(self, env, key, help, default, actual, aliases=[]):
  248.         # Don't display the key name itself as an alias.
  249.         aliases = filter(lambda a, k=key: a != k, aliases)
  250.         if len(aliases)==0:
  251.             return self.format % (key, help, default, actual)
  252.         else:
  253.             return self.format_ % (key, help, default, actual, aliases)