-"""SCons.Action

-

-This encapsulates information about executing any sort of action that

-can build one or more target Nodes (typically files) from one or more

-source Nodes (also typically files) given a specific Environment.

-

-The base class here is ActionBase. The base class supplies just a few

-OO utility methods and some generic methods for displaying information

-about an Action in response to the various commands that control printing.

-

-A second-level base class is _ActionAction. This extends ActionBase

-by providing the methods that can be used to show and perform an

-action. True Action objects will subclass _ActionAction; Action

-factory class objects will subclass ActionBase.

-

-The heavy lifting is handled by subclasses for the different types of

-actions we might execute:

-

- CommandAction

- CommandGeneratorAction

- FunctionAction

- ListAction

-

-The subclasses supply the following public interface methods used by

-other modules:

-

- __call__()

- THE public interface, "calling" an Action object executes the

- command or Python function. This also takes care of printing

- a pre-substitution command for debugging purposes.

-

- get_contents()

- Fetches the "contents" of an Action for signature calculation

- plus the varlist. This is what gets MD5 checksummed to decide

- if a target needs to be rebuilt because its action changed.

-

- genstring()

- Returns a string representation of the Action *without*

- command substitution, but allows a CommandGeneratorAction to

- generate the right action based on the specified target,

- source and env. This is used by the Signature subsystem

- (through the Executor) to obtain an (imprecise) representation

- of the Action operation for informative purposes.

-

-

-Subclasses also supply the following methods for internal use within

-this module:

-

- __str__()

- Returns a string approximation of the Action; no variable

- substitution is performed.

-

- execute()

- The internal method that really, truly, actually handles the

- execution of a command or Python function. This is used so

- that the __call__() methods can take care of displaying any

- pre-substitution representations, and *then* execute an action

- without worrying about the specific Actions involved.

-

- get_presig()

- Fetches the "contents" of a subclass for signature calculation.

- The varlist is added to this to produce the Action's contents.

-

- strfunction()

- Returns a substituted string representation of the Action.

- This is used by the _ActionAction.show() command to display the

- command/function that will be executed to generate the target(s).

-

-There is a related independent ActionCaller class that looks like a

-regular Action, and which serves as a wrapper for arbitrary functions

-that we want to let the user specify the arguments to now, but actually

-execute later (when an out-of-date check determines that it's needed to

-be executed, for example). Objects of this class are returned by an

-ActionFactory class that provides a __call__() method as a convenient

-way for wrapping up the functions.

-

-"""

-

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-

-__revision__ = "src/engine/SCons/Action.py 4043 2009/02/23 09:06:45 scons"

-

-import cPickle

-import dis

-import os

-import re

-import string

-import sys

-import subprocess

-

-from SCons.Debug import logInstanceCreation

-import SCons.Errors

-import SCons.Executor

-import SCons.Util

-import SCons.Subst

-

-# we use these a lot, so try to optimize them

-is_String = SCons.Util.is_String

-is_List = SCons.Util.is_List

-

-class _null:

- pass

-

-print_actions = 1

-execute_actions = 1

-print_actions_presub = 0

-

-def rfile(n):

- try:

- return n.rfile()

- except AttributeError:

- return n

-

-def default_exitstatfunc(s):

- return s

-

-try:

- SET_LINENO = dis.SET_LINENO

- HAVE_ARGUMENT = dis.HAVE_ARGUMENT

-except AttributeError:

- remove_set_lineno_codes = lambda x: x

-else:

- def remove_set_lineno_codes(code):

- result = []

- n = len(code)

- i = 0

- while i < n:

- c = code[i]

- op = ord(c)

- if op >= HAVE_ARGUMENT:

- if op != SET_LINENO:

- result.append(code[i:i+3])

- i = i+3

- else:

- result.append(c)

- i = i+1

- return string.join(result, '')

-

-strip_quotes = re.compile('^[\'"](.*)[\'"]$')

-

-

-def _callable_contents(obj):

- """Return the signature contents of a callable Python object.

- """

- try:

- # Test if obj is a method.

- return _function_contents(obj.im_func)

-

- except AttributeError:

- try:

- # Test if obj is a callable object.

- return _function_contents(obj.__call__.im_func)

-

- except AttributeError:

- try:

- # Test if obj is a code object.

- return _code_contents(obj)

-

- except AttributeError:

- # Test if obj is a function object.

- return _function_contents(obj)

-

-

-def _object_contents(obj):

- """Return the signature contents of any Python object.

-

- We have to handle the case where object contains a code object

- since it can be pickled directly.

- """

- try:

- # Test if obj is a method.

- return _function_contents(obj.im_func)

-

- except AttributeError:

- try:

- # Test if obj is a callable object.

- return _function_contents(obj.__call__.im_func)

-

- except AttributeError:

- try:

- # Test if obj is a code object.

- return _code_contents(obj)

-

- except AttributeError:

- try:

- # Test if obj is a function object.

- return _function_contents(obj)

-

- except AttributeError:

- # Should be a pickable Python object.

- try:

- return cPickle.dumps(obj)

- except (cPickle.PicklingError, TypeError):

- # This is weird, but it seems that nested classes

- # are unpickable. The Python docs say it should

- # always be a PicklingError, but some Python

- # versions seem to return TypeError. Just do

- # the best we can.

- return str(obj)

-

-

-def _code_contents(code):

- """Return the signature contents of a code object.

-

- By providing direct access to the code object of the

- function, Python makes this extremely easy. Hooray!

-

- Unfortunately, older versions of Python include line

- number indications in the compiled byte code. Boo!

- So we remove the line number byte codes to prevent

- recompilations from moving a Python function.

- """

-

- contents = []

-

- # The code contents depends on the number of local variables

- # but not their actual names.

- contents.append("%s,%s" % (code.co_argcount, len(code.co_varnames)))

- try:

- contents.append(",%s,%s" % (len(code.co_cellvars), len(code.co_freevars)))

- except AttributeError:

- # Older versions of Python do not support closures.

- contents.append(",0,0")

-

- # The code contents depends on any constants accessed by the

- # function. Note that we have to call _object_contents on each

- # constants because the code object of nested functions can

- # show-up among the constants.

- #

- # Note that we also always ignore the first entry of co_consts

- # which contains the function doc string. We assume that the

- # function does not access its doc string.

- contents.append(',(' + string.join(map(_object_contents,code.co_consts[1:]),',') + ')')

-

- # The code contents depends on the variable names used to

- # accessed global variable, as changing the variable name changes

- # the variable actually accessed and therefore changes the

- # function result.

- contents.append(',(' + string.join(map(_object_contents,code.co_names),',') + ')')

-

-

- # The code contents depends on its actual code!!!

- contents.append(',(' + str(remove_set_lineno_codes(code.co_code)) + ')')

-

- return string.join(contents, '')

-

-

-def _function_contents(func):

- """Return the signature contents of a function."""

-

- contents = [_code_contents(func.func_code)]

-

- # The function contents depends on the value of defaults arguments

- if func.func_defaults:

- contents.append(',(' + string.join(map(_object_contents,func.func_defaults),',') + ')')

- else:

- contents.append(',()')

-

- # The function contents depends on the closure captured cell values.

- try:

- closure = func.func_closure or []

- except AttributeError:

- # Older versions of Python do not support closures.

- closure = []

-

- #xxx = [_object_contents(x.cell_contents) for x in closure]

- try:

- xxx = map(lambda x: _object_contents(x.cell_contents), closure)

- except AttributeError:

- xxx = []

- contents.append(',(' + string.join(xxx, ',') + ')')

-

- return string.join(contents, '')

-

-

-def _actionAppend(act1, act2):

- # This function knows how to slap two actions together.

- # Mainly, it handles ListActions by concatenating into

- # a single ListAction.

- a1 = Action(act1)

- a2 = Action(act2)

- if a1 is None or a2 is None:

- raise TypeError, "Cannot append %s to %s" % (type(act1), type(act2))

- if isinstance(a1, ListAction):

- if isinstance(a2, ListAction):

- return ListAction(a1.list + a2.list)

- else:

- return ListAction(a1.list + [ a2 ])

- else:

- if isinstance(a2, ListAction):

- return ListAction([ a1 ] + a2.list)

- else:

- return ListAction([ a1, a2 ])

-

-def _do_create_keywords(args, kw):

- """This converts any arguments after the action argument into

- their equivalent keywords and adds them to the kw argument.

- """

- v = kw.get('varlist', ())

- # prevent varlist="FOO" from being interpreted as ['F', 'O', 'O']

- if is_String(v): v = (v,)

- kw['varlist'] = tuple(v)

- if args:

- # turn positional args into equivalent keywords

- cmdstrfunc = args[0]

- if cmdstrfunc is None or is_String(cmdstrfunc):

- kw['cmdstr'] = cmdstrfunc

- elif callable(cmdstrfunc):

- kw['strfunction'] = cmdstrfunc

- else:

- raise SCons.Errors.UserError(

- 'Invalid command display variable type. '

- 'You must either pass a string or a callback which '

- 'accepts (target, source, env) as parameters.')

- if len(args) > 1:

- kw['varlist'] = args[1:] + kw['varlist']

- if kw.get('strfunction', _null) is not _null \

- and kw.get('cmdstr', _null) is not _null:

- raise SCons.Errors.UserError(

- 'Cannot have both strfunction and cmdstr args to Action()')

-

-def _do_create_action(act, kw):

- """This is the actual "implementation" for the

- Action factory method, below. This handles the

- fact that passing lists to Action() itself has

- different semantics than passing lists as elements

- of lists.

-

- The former will create a ListAction, the latter

- will create a CommandAction by converting the inner

- list elements to strings."""

-

- if isinstance(act, ActionBase):

- return act

-

- if is_List(act):

- #TODO(1.5) return CommandAction(act, **kw)

- return apply(CommandAction, (act,), kw)

-

- if callable(act):

- try:

- gen = kw['generator']

- del kw['generator']

- except KeyError:

- gen = 0

- if gen:

- action_type = CommandGeneratorAction

- else:

- action_type = FunctionAction

- return action_type(act, kw)

-

- if is_String(act):

- var=SCons.Util.get_environment_var(act)

- if var:

- # This looks like a string that is purely an Environment

- # variable reference, like "$FOO" or "${FOO}". We do

- # something special here...we lazily evaluate the contents

- # of that Environment variable, so a user could put something

- # like a function or a CommandGenerator in that variable

- # instead of a string.

- return LazyAction(var, kw)

- commands = string.split(str(act), '\n')

- if len(commands) == 1:

- #TODO(1.5) return CommandAction(commands[0], **kw)

- return apply(CommandAction, (commands[0],), kw)

- # The list of string commands may include a LazyAction, so we

- # reprocess them via _do_create_list_action.

- return _do_create_list_action(commands, kw)

- return None

-

-def _do_create_list_action(act, kw):

- """A factory for list actions. Convert the input list into Actions

- and then wrap them in a ListAction."""

- acts = []

- for a in act:

- aa = _do_create_action(a, kw)

- if aa is not None: acts.append(aa)

- if not acts:

- return ListAction([])

- elif len(acts) == 1:

- return acts[0]

- else:

- return ListAction(acts)

-

-def Action(act, *args, **kw):

- """A factory for action objects."""

- # Really simple: the _do_create_* routines do the heavy lifting.

- _do_create_keywords(args, kw)

- if is_List(act):

- return _do_create_list_action(act, kw)

- return _do_create_action(act, kw)

-

-class ActionBase:

- """Base class for all types of action objects that can be held by

- other objects (Builders, Executors, etc.) This provides the

- common methods for manipulating and combining those actions."""

-

- def __cmp__(self, other):

- return cmp(self.__dict__, other)

-

- def no_batch_key(self, env, target, source):

- return None

-

- batch_key = no_batch_key

-

- def genstring(self, target, source, env):

- return str(self)

-

- def get_contents(self, target, source, env):

- result = [ self.get_presig(target, source, env) ]

- # This should never happen, as the Action() factory should wrap

- # the varlist, but just in case an action is created directly,

- # we duplicate this check here.

- vl = self.varlist

- if is_String(vl): vl = (vl,)

- for v in vl:

- result.append(env.subst('${'+v+'}'))

- return string.join(result, '')

-

- def __add__(self, other):

- return _actionAppend(self, other)

-

- def __radd__(self, other):

- return _actionAppend(other, self)

-

- def presub_lines(self, env):

- # CommandGeneratorAction needs a real environment

- # in order to return the proper string here, since

- # it may call LazyAction, which looks up a key

- # in that env. So we temporarily remember the env here,

- # and CommandGeneratorAction will use this env

- # when it calls its _generate method.

- self.presub_env = env

- lines = string.split(str(self), '\n')

- self.presub_env = None # don't need this any more

- return lines

-

- def get_targets(self, env, executor):

- """

- Returns the type of targets ($TARGETS, $CHANGED_TARGETS) used

- by this action.

- """

- return self.targets

-

-class _ActionAction(ActionBase):

- """Base class for actions that create output objects."""

- def __init__(self, cmdstr=_null, strfunction=_null, varlist=(),

- presub=_null, chdir=None, exitstatfunc=None,

- batch_key=None, targets='$TARGETS',

- **kw):

- self.cmdstr = cmdstr

- if strfunction is not _null:

- if strfunction is None:

- self.cmdstr = None

- else:

- self.strfunction = strfunction

- self.varlist = varlist

- self.presub = presub

- self.chdir = chdir

- if not exitstatfunc:

- exitstatfunc = default_exitstatfunc

- self.exitstatfunc = exitstatfunc

-

- self.targets = targets

-

- if batch_key:

- if not callable(batch_key):

- # They have set batch_key, but not to their own

- # callable. The default behavior here will batch

- # *all* targets+sources using this action, separated

- # for each construction environment.

- def default_batch_key(self, env, target, source):

- return (id(self), id(env))

- batch_key = default_batch_key

- SCons.Util.AddMethod(self, batch_key, 'batch_key')

-

- def print_cmd_line(self, s, target, source, env):

- sys.stdout.write(s + "\n")

-

- def __call__(self, target, source, env,

- exitstatfunc=_null,

- presub=_null,

- show=_null,

- execute=_null,

- chdir=_null,

- executor=None):

- if not is_List(target):

- target = [target]

- if not is_List(source):

- source = [source]

-

- if presub is _null:

- presub = self.presub

- if presub is _null:

- presub = print_actions_presub

- if exitstatfunc is _null: exitstatfunc = self.exitstatfunc

- if show is _null: show = print_actions

- if execute is _null: execute = execute_actions

- if chdir is _null: chdir = self.chdir

- save_cwd = None

- if chdir:

- save_cwd = os.getcwd()

- try:

- chdir = str(chdir.abspath)

- except AttributeError:

- if not is_String(chdir):

- if executor:

- chdir = str(executor.batches[0].targets[0].dir)

- else:

- chdir = str(target[0].dir)

- if presub:

- if executor:

- target = executor.get_all_targets()

- source = executor.get_all_sources()

- t = string.join(map(str, target), ' and ')

- l = string.join(self.presub_lines(env), '\n ')

- out = "Building %s with action:\n %s\n" % (t, l)

- sys.stdout.write(out)

- cmd = None

- if show and self.strfunction:

- if executor:

- target = executor.get_all_targets()

- source = executor.get_all_sources()

- try:

- cmd = self.strfunction(target, source, env, executor)

- except TypeError:

- cmd = self.strfunction(target, source, env)

- if cmd:

- if chdir:

- cmd = ('os.chdir(%s)\n' % repr(chdir)) + cmd

- try:

- get = env.get

- except AttributeError:

- print_func = self.print_cmd_line

- else:

- print_func = get('PRINT_CMD_LINE_FUNC')

- if not print_func:

- print_func = self.print_cmd_line

- print_func(cmd, target, source, env)

- stat = 0

- if execute:

- if chdir:

- os.chdir(chdir)

- try:

- stat = self.execute(target, source, env, executor=executor)

- if isinstance(stat, SCons.Errors.BuildError):

- s = exitstatfunc(stat.status)

- if s:

- stat.status = s

- else:

- stat = s

- else:

- stat = exitstatfunc(stat)

- finally:

- if save_cwd:

- os.chdir(save_cwd)

- if cmd and save_cwd:

- print_func('os.chdir(%s)' % repr(save_cwd), target, source, env)

-

- return stat

-

-

-def _string_from_cmd_list(cmd_list):

- """Takes a list of command line arguments and returns a pretty

- representation for printing."""

- cl = []

- for arg in map(str, cmd_list):

- if ' ' in arg or '\t' in arg:

- arg = '"' + arg + '"'

- cl.append(arg)

- return string.join(cl)

-

-# A fiddlin' little function that has an 'import SCons.Environment' which

-# can't be moved to the top level without creating an import loop. Since

-# this import creates a local variable named 'SCons', it blocks access to

-# the global variable, so we move it here to prevent complaints about local

-# variables being used uninitialized.

-default_ENV = None

-def get_default_ENV(env):

- global default_ENV

- try:

- return env['ENV']

- except KeyError:

- if not default_ENV:

- import SCons.Environment

- # This is a hideously expensive way to get a default shell

- # environment. What it really should do is run the platform

- # setup to get the default ENV. Fortunately, it's incredibly

- # rare for an Environment not to have a shell environment, so

- # we're not going to worry about it overmuch.

- default_ENV = SCons.Environment.Environment()['ENV']

- return default_ENV

-

-# This function is still in draft mode. We're going to need something like

-# it in the long run as more and more places use subprocess, but I'm sure

-# it'll have to be tweaked to get the full desired functionality.

-# one special arg (so far?), 'error', to tell what to do with exceptions.

-def _subproc(env, cmd, error = 'ignore', **kw):

- """Do common setup for a subprocess.Popen() call"""

- # allow std{in,out,err} to be "'devnull'"

- io = kw.get('stdin')

- if is_String(io) and io == 'devnull':

- kw['stdin'] = open(os.devnull)

- io = kw.get('stdout')

- if is_String(io) and io == 'devnull':

- kw['stdout'] = open(os.devnull, 'w')

- io = kw.get('stderr')

- if is_String(io) and io == 'devnull':

- kw['stderr'] = open(os.devnull, 'w')

-

- # Figure out what shell environment to use

- ENV = kw.get('env', None)

- if ENV is None: ENV = get_default_ENV(env)

-

- # Ensure that the ENV values are all strings:

- new_env = {}

- for key, value in ENV.items():

- if is_List(value):

- # If the value is a list, then we assume it is a path list,

- # because that's a pretty common list-like value to stick

- # in an environment variable:

- value = SCons.Util.flatten_sequence(value)

- new_env[key] = string.join(map(str, value), os.pathsep)

- else:

- # It's either a string or something else. If it's a string,

- # we still want to call str() because it might be a *Unicode*

- # string, which makes subprocess.Popen() gag. If it isn't a

- # string or a list, then we just coerce it to a string, which

- # is the proper way to handle Dir and File instances and will

- # produce something reasonable for just about everything else:

- new_env[key] = str(value)

- kw['env'] = new_env

-

- try:

- #FUTURE return subprocess.Popen(cmd, **kw)

- return apply(subprocess.Popen, (cmd,), kw)

- except EnvironmentError, e:

- if error == 'raise': raise

- # return a dummy Popen instance that only returns error

- class dummyPopen:

- def __init__(self, e): self.exception = e

- def communicate(self): return ('','')

- def wait(self): return -self.exception.errno

- stdin = None

- class f:

- def read(self): return ''

- def readline(self): return ''

- stdout = stderr = f()

- return dummyPopen(e)

-

-class CommandAction(_ActionAction):

- """Class for command-execution actions."""

- def __init__(self, cmd, **kw):

- # Cmd can actually be a list or a single item; if it's a

- # single item it should be the command string to execute; if a

- # list then it should be the words of the command string to

- # execute. Only a single command should be executed by this

- # object; lists of commands should be handled by embedding

- # these objects in a ListAction object (which the Action()

- # factory above does). cmd will be passed to

- # Environment.subst_list() for substituting environment

- # variables.

- if __debug__: logInstanceCreation(self, 'Action.CommandAction')

-

- #TODO(1.5) _ActionAction.__init__(self, **kw)

- apply(_ActionAction.__init__, (self,), kw)

- if is_List(cmd):

- if filter(is_List, cmd):

- raise TypeError, "CommandAction should be given only " \

- "a single command"

- self.cmd_list = cmd

-

- def __str__(self):

- if is_List(self.cmd_list):

- return string.join(map(str, self.cmd_list), ' ')

- return str(self.cmd_list)

-

- def process(self, target, source, env, executor=None):

- if executor:

- result = env.subst_list(self.cmd_list, 0, executor=executor)

- else:

- result = env.subst_list(self.cmd_list, 0, target, source)

- silent = None

- ignore = None

- while 1:

- try: c = result[0][0][0]

- except IndexError: c = None

- if c == '@': silent = 1

- elif c == '-': ignore = 1

- else: break

- result[0][0] = result[0][0][1:]

- try:

- if not result[0][0]:

- result[0] = result[0][1:]

- except IndexError:

- pass

- return result, ignore, silent

-

- def strfunction(self, target, source, env, executor=None):

- if self.cmdstr is None:

- return None

- if self.cmdstr is not _null:

- from SCons.Subst import SUBST_RAW

- if executor:

- c = env.subst(self.cmdstr, SUBST_RAW, executor=executor)

- else:

- c = env.subst(self.cmdstr, SUBST_RAW, target, source)

- if c:

- return c

- cmd_list, ignore, silent = self.process(target, source, env, executor)

- if silent:

- return ''

- return _string_from_cmd_list(cmd_list[0])

-

- def execute(self, target, source, env, executor=None):

- """Execute a command action.

-

- This will handle lists of commands as well as individual commands,

- because construction variable substitution may turn a single

- "command" into a list. This means that this class can actually

- handle lists of commands, even though that's not how we use it

- externally.

- """

- escape_list = SCons.Subst.escape_list

- flatten_sequence = SCons.Util.flatten_sequence

-

- try:

- shell = env['SHELL']

- except KeyError:

- raise SCons.Errors.UserError('Missing SHELL construction variable.')

-

- try:

- spawn = env['SPAWN']

- except KeyError:

- raise SCons.Errors.UserError('Missing SPAWN construction variable.')

- else:

- if is_String(spawn):

- spawn = env.subst(spawn, raw=1, conv=lambda x: x)

-

- escape = env.get('ESCAPE', lambda x: x)

-

- ENV = get_default_ENV(env)

-

- # Ensure that the ENV values are all strings:

- for key, value in ENV.items():

- if not is_String(value):

- if is_List(value):

- # If the value is a list, then we assume it is a

- # path list, because that's a pretty common list-like

- # value to stick in an environment variable:

- value = flatten_sequence(value)

- ENV[key] = string.join(map(str, value), os.pathsep)

- else:

- # If it isn't a string or a list, then we just coerce

- # it to a string, which is the proper way to handle

- # Dir and File instances and will produce something

- # reasonable for just about everything else:

- ENV[key] = str(value)

-

- if executor:

- target = executor.get_all_targets()

- source = executor.get_all_sources()

- cmd_list, ignore, silent = self.process(target, map(rfile, source), env, executor)

-

- # Use len() to filter out any "command" that's zero-length.

- for cmd_line in filter(len, cmd_list):

- # Escape the command line for the interpreter we are using.

- cmd_line = escape_list(cmd_line, escape)

- result = spawn(shell, escape, cmd_line[0], cmd_line, ENV)

- if not ignore and result:

- msg = "Error %s" % result

- return SCons.Errors.BuildError(errstr=msg,

- status=result,

- action=self,

- command=cmd_line)

- return 0

-

- def get_presig(self, target, source, env, executor=None):

- """Return the signature contents of this action's command line.

-

- This strips $(-$) and everything in between the string,

- since those parts don't affect signatures.

- """

- from SCons.Subst import SUBST_SIG

- cmd = self.cmd_list

- if is_List(cmd):

- cmd = string.join(map(str, cmd))

- else:

- cmd = str(cmd)

- if executor:

- return env.subst_target_source(cmd, SUBST_SIG, executor=executor)

- else:

- return env.subst_target_source(cmd, SUBST_SIG, target, source)

-

- def get_implicit_deps(self, target, source, env, executor=None):

- icd = env.get('IMPLICIT_COMMAND_DEPENDENCIES', True)

- if is_String(icd) and icd[:1] == '$':

- icd = env.subst(icd)

- if not icd or icd in ('0', 'None'):

- return []

- from SCons.Subst import SUBST_SIG

- if executor:

- cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, executor=executor)

- else:

- cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, target, source)

- res = []

- for cmd_line in cmd_list:

- if cmd_line:

- d = str(cmd_line[0])

- m = strip_quotes.match(d)

- if m:

- d = m.group(1)

- d = env.WhereIs(d)

- if d:

- res.append(env.fs.File(d))

- return res

-

-class CommandGeneratorAction(ActionBase):

- """Class for command-generator actions."""

- def __init__(self, generator, kw):

- if __debug__: logInstanceCreation(self, 'Action.CommandGeneratorAction')

- self.generator = generator

- self.gen_kw = kw

- self.varlist = kw.get('varlist', ())

- self.targets = kw.get('targets', '$TARGETS')

-

- def _generate(self, target, source, env, for_signature, executor=None):

- # ensure that target is a list, to make it easier to write

- # generator functions:

- if not is_List(target):

- target = [target]

-

- if executor:

- target = executor.get_all_targets()

- source = executor.get_all_sources()

- ret = self.generator(target=target,

- source=source,

- env=env,

- for_signature=for_signature)

- #TODO(1.5) gen_cmd = Action(ret, **self.gen_kw)

- gen_cmd = apply(Action, (ret,), self.gen_kw)

- if not gen_cmd:

- raise SCons.Errors.UserError("Object returned from command generator: %s cannot be used to create an Action." % repr(ret))

- return gen_cmd

-

- def __str__(self):

- try:

- env = self.presub_env

- except AttributeError:

- env = None

- if env is None:

- env = SCons.Defaults.DefaultEnvironment()

- act = self._generate([], [], env, 1)

- return str(act)

-

- def batch_key(self, env, target, source):

- return self._generate(target, source, env, 1).batch_key(env, target, source)

-

- def genstring(self, target, source, env, executor=None):

- return self._generate(target, source, env, 1, executor).genstring(target, source, env)

-

- def __call__(self, target, source, env, exitstatfunc=_null, presub=_null,

- show=_null, execute=_null, chdir=_null, executor=None):

- act = self._generate(target, source, env, 0, executor)

- if act is None:

- raise UserError("While building `%s': Cannot deduce file extension from source files: %s" % (repr(map(str, target)), repr(map(str, source))))

- return act(target, source, env, exitstatfunc, presub,

- show, execute, chdir, executor)

-

- def get_presig(self, target, source, env, executor=None):

- """Return the signature contents of this action's command line.

-

- This strips $(-$) and everything in between the string,

- since those parts don't affect signatures.

- """

- return self._generate(target, source, env, 1, executor).get_presig(target, source, env)

-

- def get_implicit_deps(self, target, source, env, executor=None):

- return self._generate(target, source, env, 1, executor).get_implicit_deps(target, source, env)

-

- def get_targets(self, env, executor):

- return self._generate(None, None, env, 1, executor).get_targets(env, executor)

-

-

-

-# A LazyAction is a kind of hybrid generator and command action for

-# strings of the form "$VAR". These strings normally expand to other

-# strings (think "$CCCOM" to "$CC -c -o $TARGET $SOURCE"), but we also

-# want to be able to replace them with functions in the construction

-# environment. Consequently, we want lazy evaluation and creation of

-# an Action in the case of the function, but that's overkill in the more

-# normal case of expansion to other strings.

-#

-# So we do this with a subclass that's both a generator *and*

-# a command action. The overridden methods all do a quick check

-# of the construction variable, and if it's a string we just call

-# the corresponding CommandAction method to do the heavy lifting.

-# If not, then we call the same-named CommandGeneratorAction method.

-# The CommandGeneratorAction methods work by using the overridden

-# _generate() method, that is, our own way of handling "generation" of

-# an action based on what's in the construction variable.

-

-class LazyAction(CommandGeneratorAction, CommandAction):

-

- def __init__(self, var, kw):

- if __debug__: logInstanceCreation(self, 'Action.LazyAction')

- #FUTURE CommandAction.__init__(self, '${'+var+'}', **kw)

- apply(CommandAction.__init__, (self, '${'+var+'}'), kw)

- self.var = SCons.Util.to_String(var)

- self.gen_kw = kw

-

- def get_parent_class(self, env):

- c = env.get(self.var)

- if is_String(c) and not '\n' in c:

- return CommandAction

- return CommandGeneratorAction

-

- def _generate_cache(self, env):

- if env:

- c = env.get(self.var, '')

- else:

- c = ''

- #TODO(1.5) gen_cmd = Action(c, **self.gen_kw)

- gen_cmd = apply(Action, (c,), self.gen_kw)

- if not gen_cmd:

- raise SCons.Errors.UserError("$%s value %s cannot be used to create an Action." % (self.var, repr(c)))

- return gen_cmd

-

- def _generate(self, target, source, env, for_signature, executor=None):

- return self._generate_cache(env)

-

- def __call__(self, target, source, env, *args, **kw):

- args = (self, target, source, env) + args

- c = self.get_parent_class(env)

- #TODO(1.5) return c.__call__(*args, **kw)

- return apply(c.__call__, args, kw)

-

- def get_presig(self, target, source, env):

- c = self.get_parent_class(env)

- return c.get_presig(self, target, source, env)

-

-

-

-class FunctionAction(_ActionAction):

- """Class for Python function actions."""

-

- def __init__(self, execfunction, kw):

- if __debug__: logInstanceCreation(self, 'Action.FunctionAction')

-

- self.execfunction = execfunction

- try:

- self.funccontents = _callable_contents(execfunction)

- except AttributeError:

- try:

- # See if execfunction will do the heavy lifting for us.

- self.gc = execfunction.get_contents

- except AttributeError:

- # This is weird, just do the best we can.

- self.funccontents = _object_contents(execfunction)

-

- #TODO(1.5) _ActionAction.__init__(self, **kw)

- apply(_ActionAction.__init__, (self,), kw)

-

- def function_name(self):

- try:

- return self.execfunction.__name__

- except AttributeError:

- try:

- return self.execfunction.__class__.__name__

- except AttributeError:

- return "unknown_python_function"

-

- def strfunction(self, target, source, env, executor=None):

- if self.cmdstr is None:

- return None

- if self.cmdstr is not _null:

- from SCons.Subst import SUBST_RAW

- if executor:

- c = env.subst(self.cmdstr, SUBST_RAW, executor=executor)

- else:

- c = env.subst(self.cmdstr, SUBST_RAW, target, source)

- if c:

- return c

- def array(a):

- def quote(s):

- try:

- str_for_display = s.str_for_display

- except AttributeError:

- s = repr(s)

- else:

- s = str_for_display()

- return s

- return '[' + string.join(map(quote, a), ", ") + ']'

- try:

- strfunc = self.execfunction.strfunction

- except AttributeError:

- pass

- else:

- if strfunc is None:

- return None

- if callable(strfunc):

- return strfunc(target, source, env)

- name = self.function_name()

- tstr = array(target)

- sstr = array(source)

- return "%s(%s, %s)" % (name, tstr, sstr)

-

- def __str__(self):

- name = self.function_name()

- if name == 'ActionCaller':

- return str(self.execfunction)

- return "%s(target, source, env)" % name

-

- def execute(self, target, source, env, executor=None):

- exc_info = (None,None,None)

- try:

- if executor:

- target = executor.get_all_targets()

- source = executor.get_all_sources()

- rsources = map(rfile, source)

- try:

- result = self.execfunction(target=target, source=rsources, env=env)

- except KeyboardInterrupt, e:

- raise

- except SystemExit, e:

- raise

- except Exception, e:

- result = e

- exc_info = sys.exc_info()

-

- if result:

- result = SCons.Errors.convert_to_BuildError(result, exc_info)

- result.node=target

- result.action=self

- try:

- result.command=self.strfunction(target, source, env, executor)

- except TypeError:

- result.command=self.strfunction(target, source, env)

-

- # FIXME: This maintains backward compatibility with respect to

- # which type of exceptions were returned by raising an

- # exception and which ones were returned by value. It would

- # probably be best to always return them by value here, but

- # some codes do not check the return value of Actions and I do

- # not have the time to modify them at this point.

- if (exc_info[1] and

- not isinstance(exc_info[1],EnvironmentError)):

- raise result

-

- return result

- finally:

- # Break the cycle between the traceback object and this

- # function stack frame. See the sys.exc_info() doc info for

- # more information about this issue.

- del exc_info

-

-

- def get_presig(self, target, source, env):

- """Return the signature contents of this callable action."""

- try:

- return self.gc(target, source, env)

- except AttributeError:

- return self.funccontents

-

- def get_implicit_deps(self, target, source, env):

- return []

-

-class ListAction(ActionBase):

- """Class for lists of other actions."""

- def __init__(self, list):

- if __debug__: logInstanceCreation(self, 'Action.ListAction')

- def list_of_actions(x):

- if isinstance(x, ActionBase):

- return x

- return Action(x)

- self.list = map(list_of_actions, list)

- # our children will have had any varlist

- # applied; we don't need to do it again

- self.varlist = ()

- self.targets = '$TARGETS'

-

- def genstring(self, target, source, env):

- return string.join(map(lambda a, t=target, s=source, e=env:

- a.genstring(t, s, e),

- self.list),

- '\n')

-

- def __str__(self):

- return string.join(map(str, self.list), '\n')

-

- def presub_lines(self, env):

- return SCons.Util.flatten_sequence(

- map(lambda a, env=env: a.presub_lines(env), self.list))

-

- def get_presig(self, target, source, env):

- """Return the signature contents of this action list.

-

- Simple concatenation of the signatures of the elements.

- """

- return string.join(map(lambda x, t=target, s=source, e=env:

- x.get_contents(t, s, e),

- self.list),

- "")

-

- def __call__(self, target, source, env, exitstatfunc=_null, presub=_null,

- show=_null, execute=_null, chdir=_null, executor=None):

- if executor:

- target = executor.get_all_targets()

- source = executor.get_all_sources()

- for act in self.list:

- stat = act(target, source, env, exitstatfunc, presub,

- show, execute, chdir, executor)

- if stat:

- return stat

- return 0

-

- def get_implicit_deps(self, target, source, env):

- result = []

- for act in self.list:

- result.extend(act.get_implicit_deps(target, source, env))

- return result

-

-class ActionCaller:

- """A class for delaying calling an Action function with specific

- (positional and keyword) arguments until the Action is actually

- executed.

-

- This class looks to the rest of the world like a normal Action object,

- but what it's really doing is hanging on to the arguments until we

- have a target, source and env to use for the expansion.

- """

- def __init__(self, parent, args, kw):

- self.parent = parent

- self.args = args

- self.kw = kw

-

- def get_contents(self, target, source, env):

- actfunc = self.parent.actfunc

- try:

- # "self.actfunc" is a function.

- contents = str(actfunc.func_code.co_code)

- except AttributeError:

- # "self.actfunc" is a callable object.

- try:

- contents = str(actfunc.__call__.im_func.func_code.co_code)

- except AttributeError:

- # No __call__() method, so it might be a builtin

- # or something like that. Do the best we can.

- contents = str(actfunc)

- contents = remove_set_lineno_codes(contents)

- return contents

-

- def subst(self, s, target, source, env):

- # If s is a list, recursively apply subst()

- # to every element in the list

- if is_List(s):

- result = []

- for elem in s:

- result.append(self.subst(elem, target, source, env))

- return self.parent.convert(result)

-

- # Special-case hack: Let a custom function wrapped in an

- # ActionCaller get at the environment through which the action

- # was called by using this hard-coded value as a special return.

- if s == '$__env__':

- return env

- elif is_String(s):

- return env.subst(s, 1, target, source)

- return self.parent.convert(s)

-

- def subst_args(self, target, source, env):

- return map(lambda x, self=self, t=target, s=source, e=env:

- self.subst(x, t, s, e),

- self.args)

-

- def subst_kw(self, target, source, env):

- kw = {}

- for key in self.kw.keys():

- kw[key] = self.subst(self.kw[key], target, source, env)

- return kw

-

- def __call__(self, target, source, env, executor=None):

- args = self.subst_args(target, source, env)

- kw = self.subst_kw(target, source, env)

- #TODO(1.5) return self.parent.actfunc(*args, **kw)

- return apply(self.parent.actfunc, args, kw)

-

- def strfunction(self, target, source, env):

- args = self.subst_args(target, source, env)

- kw = self.subst_kw(target, source, env)

- #TODO(1.5) return self.parent.strfunc(*args, **kw)

- return apply(self.parent.strfunc, args, kw)

-

- def __str__(self):

- #TODO(1.5) return self.parent.strfunc(*self.args, **self.kw)

- return apply(self.parent.strfunc, self.args, self.kw)

-

-class ActionFactory:

- """A factory class that will wrap up an arbitrary function

- as an SCons-executable Action object.

-

- The real heavy lifting here is done by the ActionCaller class.

- We just collect the (positional and keyword) arguments that we're

- called with and give them to the ActionCaller object we create,

- so it can hang onto them until it needs them.

- """

- def __init__(self, actfunc, strfunc, convert=lambda x: x):

- self.actfunc = actfunc

- self.strfunc = strfunc

- self.convert = convert

-

- def __call__(self, *args, **kw):

- ac = ActionCaller(self, args, kw)

- action = Action(ac, strfunction=ac.strfunction)

- return action

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

-"""SCons.Builder

-

-Builder object subsystem.

-

-A Builder object is a callable that encapsulates information about how

-to execute actions to create a target Node (file) from source Nodes

-(files), and how to create those dependencies for tracking.

-

-The main entry point here is the Builder() factory method. This provides

-a procedural interface that creates the right underlying Builder object

-based on the keyword arguments supplied and the types of the arguments.

-

-The goal is for this external interface to be simple enough that the

-vast majority of users can create new Builders as necessary to support

-building new types of files in their configurations, without having to

-dive any deeper into this subsystem.

-

-The base class here is BuilderBase. This is a concrete base class which

-does, in fact, represent the Builder objects that we (or users) create.

-

-There is also a proxy that looks like a Builder:

-

- CompositeBuilder

-

- This proxies for a Builder with an action that is actually a

- dictionary that knows how to map file suffixes to a specific

- action. This is so that we can invoke different actions

- (compilers, compile options) for different flavors of source

- files.

-

-Builders and their proxies have the following public interface methods

-used by other modules:

-

- __call__()

- THE public interface. Calling a Builder object (with the

- use of internal helper methods) sets up the target and source

- dependencies, appropriate mapping to a specific action, and the

- environment manipulation necessary for overridden construction

- variable. This also takes care of warning about possible mistakes

- in keyword arguments.

-

- add_emitter()

- Adds an emitter for a specific file suffix, used by some Tool

- modules to specify that (for example) a yacc invocation on a .y

- can create a .h *and* a .c file.

-

- add_action()

- Adds an action for a specific file suffix, heavily used by

- Tool modules to add their specific action(s) for turning

- a source file into an object file to the global static

- and shared object file Builders.

-

-There are the following methods for internal use within this module:

-

- _execute()

- The internal method that handles the heavily lifting when a

- Builder is called. This is used so that the __call__() methods

- can set up warning about possible mistakes in keyword-argument

- overrides, and *then* execute all of the steps necessary so that

- the warnings only occur once.

-

- get_name()

- Returns the Builder's name within a specific Environment,

- primarily used to try to return helpful information in error

- messages.

-

- adjust_suffix()

- get_prefix()

- get_suffix()

- get_src_suffix()

- set_src_suffix()

- Miscellaneous stuff for handling the prefix and suffix

- manipulation we use in turning source file names into target

- file names.

-

-"""

-

-#

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-__revision__ = "src/engine/SCons/Builder.py 4043 2009/02/23 09:06:45 scons"

-

-import UserDict

-import UserList

-

-import SCons.Action

-from SCons.Debug import logInstanceCreation

-from SCons.Errors import InternalError, UserError

-import SCons.Executor

-import SCons.Memoize

-import SCons.Node

-import SCons.Node.FS

-import SCons.Util

-import SCons.Warnings

-

-class _Null:

- pass

-

-_null = _Null

-

-def match_splitext(path, suffixes = []):

- if suffixes:

- matchsuf = filter(lambda S,path=path: path[-len(S):] == S,

- suffixes)

- if matchsuf:

- suf = max(map(None, map(len, matchsuf), matchsuf))[1]

- return [path[:-len(suf)], path[-len(suf):]]

- return SCons.Util.splitext(path)

-

-class DictCmdGenerator(SCons.Util.Selector):

- """This is a callable class that can be used as a

- command generator function. It holds on to a dictionary

- mapping file suffixes to Actions. It uses that dictionary

- to return the proper action based on the file suffix of

- the source file."""

-

- def __init__(self, dict=None, source_ext_match=1):

- SCons.Util.Selector.__init__(self, dict)

- self.source_ext_match = source_ext_match

-

- def src_suffixes(self):

- return self.keys()

-

- def add_action(self, suffix, action):

- """Add a suffix-action pair to the mapping.

- """

- self[suffix] = action

-

- def __call__(self, target, source, env, for_signature):

- if not source:

- return []

-

- if self.source_ext_match:

- suffixes = self.src_suffixes()

- ext = None

- for src in map(str, source):

- my_ext = match_splitext(src, suffixes)[1]

- if ext and my_ext != ext:

- raise UserError("While building `%s' from `%s': Cannot build multiple sources with different extensions: %s, %s" % (repr(map(str, target)), src, ext, my_ext))

- ext = my_ext

- else:

- ext = match_splitext(str(source[0]), self.src_suffixes())[1]

-

- if not ext:

- #return ext

- raise UserError("While building `%s': Cannot deduce file extension from source files: %s" % (repr(map(str, target)), repr(map(str, source))))

-

- try:

- ret = SCons.Util.Selector.__call__(self, env, source, ext)

- except KeyError, e:

- raise UserError("Ambiguous suffixes after environment substitution: %s == %s == %s" % (e[0], e[1], e[2]))

- if ret is None:

- raise UserError("While building `%s' from `%s': Don't know how to build from a source file with suffix `%s'. Expected a suffix in this list: %s." % \

- (repr(map(str, target)), repr(map(str, source)), ext, repr(self.keys())))

- return ret

-

-class CallableSelector(SCons.Util.Selector):

- """A callable dictionary that will, in turn, call the value it

- finds if it can."""

- def __call__(self, env, source):

- value = SCons.Util.Selector.__call__(self, env, source)

- if callable(value):

- value = value(env, source)

- return value

-

-class DictEmitter(SCons.Util.Selector):

- """A callable dictionary that maps file suffixes to emitters.

- When called, it finds the right emitter in its dictionary for the

- suffix of the first source file, and calls that emitter to get the

- right lists of targets and sources to return. If there's no emitter

- for the suffix in its dictionary, the original target and source are

- returned.

- """

- def __call__(self, target, source, env):

- emitter = SCons.Util.Selector.__call__(self, env, source)

- if emitter:

- target, source = emitter(target, source, env)

- return (target, source)

-

-class ListEmitter(UserList.UserList):

- """A callable list of emitters that calls each in sequence,

- returning the result.

- """

- def __call__(self, target, source, env):

- for e in self.data:

- target, source = e(target, source, env)

- return (target, source)

-

-# These are a common errors when calling a Builder;

-# they are similar to the 'target' and 'source' keyword args to builders,

-# so we issue warnings when we see them. The warnings can, of course,

-# be disabled.

-misleading_keywords = {

- 'targets' : 'target',

- 'sources' : 'source',

-}

-

-class OverrideWarner(UserDict.UserDict):

- """A class for warning about keyword arguments that we use as

- overrides in a Builder call.

-

- This class exists to handle the fact that a single Builder call

- can actually invoke multiple builders. This class only emits the

- warnings once, no matter how many Builders are invoked.

- """

- def __init__(self, dict):

- UserDict.UserDict.__init__(self, dict)

- if __debug__: logInstanceCreation(self, 'Builder.OverrideWarner')

- self.already_warned = None

- def warn(self):

- if self.already_warned:

- return

- for k in self.keys():

- if misleading_keywords.has_key(k):

- alt = misleading_keywords[k]

- msg = "Did you mean to use `%s' instead of `%s'?" % (alt, k)

- SCons.Warnings.warn(SCons.Warnings.MisleadingKeywordsWarning, msg)

- self.already_warned = 1

-

-def Builder(**kw):

- """A factory for builder objects."""

- composite = None

- if kw.has_key('generator'):

- if kw.has_key('action'):

- raise UserError, "You must not specify both an action and a generator."

- kw['action'] = SCons.Action.CommandGeneratorAction(kw['generator'], {})

- del kw['generator']

- elif kw.has_key('action'):

- source_ext_match = kw.get('source_ext_match', 1)

- if kw.has_key('source_ext_match'):

- del kw['source_ext_match']

- if SCons.Util.is_Dict(kw['action']):

- composite = DictCmdGenerator(kw['action'], source_ext_match)

- kw['action'] = SCons.Action.CommandGeneratorAction(composite, {})

- kw['src_suffix'] = composite.src_suffixes()

- else:

- kw['action'] = SCons.Action.Action(kw['action'])

-

- if kw.has_key('emitter'):

- emitter = kw['emitter']

- if SCons.Util.is_String(emitter):

- # This allows users to pass in an Environment

- # variable reference (like "$FOO") as an emitter.

- # We will look in that Environment variable for

- # a callable to use as the actual emitter.

- var = SCons.Util.get_environment_var(emitter)

- if not var:

- raise UserError, "Supplied emitter '%s' does not appear to refer to an Environment variable" % emitter

- kw['emitter'] = EmitterProxy(var)

- elif SCons.Util.is_Dict(emitter):

- kw['emitter'] = DictEmitter(emitter)

- elif SCons.Util.is_List(emitter):

- kw['emitter'] = ListEmitter(emitter)

-

- result = apply(BuilderBase, (), kw)

-

- if not composite is None:

- result = CompositeBuilder(result, composite)

-

- return result

-

-def _node_errors(builder, env, tlist, slist):

- """Validate that the lists of target and source nodes are

- legal for this builder and environment. Raise errors or

- issue warnings as appropriate.

- """

-

- # First, figure out if there are any errors in the way the targets

- # were specified.

- for t in tlist:

- if t.side_effect:

- raise UserError, "Multiple ways to build the same target were specified for: %s" % t

- if t.has_explicit_builder():

- if not t.env is None and not t.env is env:

- action = t.builder.action

- t_contents = action.get_contents(tlist, slist, t.env)

- contents = action.get_contents(tlist, slist, env)

-

- if t_contents == contents:

- msg = "Two different environments were specified for target %s,\n\tbut they appear to have the same action: %s" % (t, action.genstring(tlist, slist, t.env))

- SCons.Warnings.warn(SCons.Warnings.DuplicateEnvironmentWarning, msg)

- else:

- msg = "Two environments with different actions were specified for the same target: %s" % t

- raise UserError, msg

- if builder.multi:

- if t.builder != builder:

- msg = "Two different builders (%s and %s) were specified for the same target: %s" % (t.builder.get_name(env), builder.get_name(env), t)

- raise UserError, msg

- # TODO(batch): list constructed each time!

- if t.get_executor().get_all_targets() != tlist:

- msg = "Two different target lists have a target in common: %s (from %s and from %s)" % (t, map(str, t.get_executor().get_all_targets()), map(str, tlist))

- raise UserError, msg

- elif t.sources != slist:

- msg = "Multiple ways to build the same target were specified for: %s (from %s and from %s)" % (t, map(str, t.sources), map(str, slist))

- raise UserError, msg

-

- if builder.single_source:

- if len(slist) > 1:

- raise UserError, "More than one source given for single-source builder: targets=%s sources=%s" % (map(str,tlist), map(str,slist))

-

-class EmitterProxy:

- """This is a callable class that can act as a

- Builder emitter. It holds on to a string that

- is a key into an Environment dictionary, and will

- look there at actual build time to see if it holds

- a callable. If so, we will call that as the actual

- emitter."""

- def __init__(self, var):

- self.var = SCons.Util.to_String(var)

-

- def __call__(self, target, source, env):

- emitter = self.var

-

- # Recursively substitute the variable.

- # We can't use env.subst() because it deals only

- # in strings. Maybe we should change that?

- while SCons.Util.is_String(emitter) and env.has_key(emitter):

- emitter = env[emitter]

- if callable(emitter):

- target, source = emitter(target, source, env)

- elif SCons.Util.is_List(emitter):

- for e in emitter:

- target, source = e(target, source, env)

-

- return (target, source)

-

-

- def __cmp__(self, other):

- return cmp(self.var, other.var)

-

-class BuilderBase:

- """Base class for Builders, objects that create output

- nodes (files) from input nodes (files).

- """

-

- if SCons.Memoize.use_memoizer:

- __metaclass__ = SCons.Memoize.Memoized_Metaclass

-

- memoizer_counters = []

-

- def __init__(self, action = None,

- prefix = '',

- suffix = '',

- src_suffix = '',

- target_factory = None,

- source_factory = None,

- target_scanner = None,

- source_scanner = None,

- emitter = None,

- multi = 0,

- env = None,

- single_source = 0,

- name = None,

- chdir = _null,

- is_explicit = 1,

- src_builder = None,

- ensure_suffix = False,

- **overrides):

- if __debug__: logInstanceCreation(self, 'Builder.BuilderBase')

- self._memo = {}

- self.action = action

- self.multi = multi

- if SCons.Util.is_Dict(prefix):

- prefix = CallableSelector(prefix)

- self.prefix = prefix

- if SCons.Util.is_Dict(suffix):

- suffix = CallableSelector(suffix)

- self.env = env

- self.single_source = single_source

- if overrides.has_key('overrides'):

- SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,

- "The \"overrides\" keyword to Builder() creation has been deprecated;\n" +\

- "\tspecify the items as keyword arguments to the Builder() call instead.")

- overrides.update(overrides['overrides'])

- del overrides['overrides']

- if overrides.has_key('scanner'):

- SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,

- "The \"scanner\" keyword to Builder() creation has been deprecated;\n"

- "\tuse: source_scanner or target_scanner as appropriate.")

- del overrides['scanner']

- self.overrides = overrides

-

- self.set_suffix(suffix)

- self.set_src_suffix(src_suffix)

- self.ensure_suffix = ensure_suffix

-

- self.target_factory = target_factory

- self.source_factory = source_factory

- self.target_scanner = target_scanner

- self.source_scanner = source_scanner

-

- self.emitter = emitter

-

- # Optional Builder name should only be used for Builders

- # that don't get attached to construction environments.

- if name:

- self.name = name

- self.executor_kw = {}

- if not chdir is _null:

- self.executor_kw['chdir'] = chdir

- self.is_explicit = is_explicit

-

- if src_builder is None:

- src_builder = []

- elif not SCons.Util.is_List(src_builder):

- src_builder = [ src_builder ]

- self.src_builder = src_builder

-

- def __nonzero__(self):

- raise InternalError, "Do not test for the Node.builder attribute directly; use Node.has_builder() instead"

-

- def get_name(self, env):

- """Attempts to get the name of the Builder.

-

- Look at the BUILDERS variable of env, expecting it to be a

- dictionary containing this Builder, and return the key of the

- dictionary. If there's no key, then return a directly-configured

- name (if there is one) or the name of the class (by default)."""

-

- try:

- index = env['BUILDERS'].values().index(self)

- return env['BUILDERS'].keys()[index]

- except (AttributeError, KeyError, TypeError, ValueError):

- try:

- return self.name

- except AttributeError:

- return str(self.__class__)

-

- def __cmp__(self, other):

- return cmp(self.__dict__, other.__dict__)

-

- def splitext(self, path, env=None):

- if not env:

- env = self.env

- if env:

- suffixes = self.src_suffixes(env)

- else:

- suffixes = []

- return match_splitext(path, suffixes)

-

- def _adjustixes(self, files, pre, suf, ensure_suffix=False):

- if not files:

- return []

- result = []

- if not SCons.Util.is_List(files):

- files = [files]

-

- for f in files:

- if SCons.Util.is_String(f):

- f = SCons.Util.adjustixes(f, pre, suf, ensure_suffix)

- result.append(f)

- return result

-

- def _create_nodes(self, env, target = None, source = None):

- """Create and return lists of target and source nodes.

- """

- src_suf = self.get_src_suffix(env)

-

- target_factory = env.get_factory(self.target_factory)

- source_factory = env.get_factory(self.source_factory)

-

- source = self._adjustixes(source, None, src_suf)

- slist = env.arg2nodes(source, source_factory)

-

- pre = self.get_prefix(env, slist)

- suf = self.get_suffix(env, slist)

-

- if target is None:

- try:

- t_from_s = slist[0].target_from_source

- except AttributeError:

- raise UserError("Do not know how to create a target from source `%s'" % slist[0])

- except IndexError:

- tlist = []

- else:

- splitext = lambda S,self=self,env=env: self.splitext(S,env)

- tlist = [ t_from_s(pre, suf, splitext) ]

- else:

- target = self._adjustixes(target, pre, suf, self.ensure_suffix)

- tlist = env.arg2nodes(target, target_factory, target=target, source=source)

-

- if self.emitter:

- # The emitter is going to do str(node), but because we're

- # being called *from* a builder invocation, the new targets

- # don't yet have a builder set on them and will look like

- # source files. Fool the emitter's str() calls by setting

- # up a temporary builder on the new targets.

- new_targets = []

- for t in tlist:

- if not t.is_derived():

- t.builder_set(self)

- new_targets.append(t)

-

- orig_tlist = tlist[:]

- orig_slist = slist[:]

-

- target, source = self.emitter(target=tlist, source=slist, env=env)

-

- # Now delete the temporary builders that we attached to any

- # new targets, so that _node_errors() doesn't do weird stuff

- # to them because it thinks they already have builders.

- for t in new_targets:

- if t.builder is self:

- # Only delete the temporary builder if the emitter

- # didn't change it on us.

- t.builder_set(None)

-

- # Have to call arg2nodes yet again, since it is legal for

- # emitters to spit out strings as well as Node instances.

- tlist = env.arg2nodes(target, target_factory,

- target=orig_tlist, source=orig_slist)

- slist = env.arg2nodes(source, source_factory,

- target=orig_tlist, source=orig_slist)

-

- return tlist, slist

-

- def _execute(self, env, target, source, overwarn={}, executor_kw={}):

- # We now assume that target and source are lists or None.

- if self.src_builder:

- source = self.src_builder_sources(env, source, overwarn)

-

- if self.single_source and len(source) > 1 and target is None:

- result = []

- if target is None: target = [None]*len(source)

- for tgt, src in zip(target, source):

- if not tgt is None: tgt = [tgt]

- if not src is None: src = [src]

- result.extend(self._execute(env, tgt, src, overwarn))

- return SCons.Node.NodeList(result)

-

- overwarn.warn()

-

- tlist, slist = self._create_nodes(env, target, source)

-

- # Check for errors with the specified target/source lists.

- _node_errors(self, env, tlist, slist)

-

- # The targets are fine, so find or make the appropriate Executor to

- # build this particular list of targets from this particular list of

- # sources.

-

- executor = None

- key = None

-

- if self.multi:

- try:

- executor = tlist[0].get_executor(create = 0)

- except (AttributeError, IndexError):

- pass

- else:

- executor.add_sources(slist)

-

- if executor is None:

- if not self.action:

- fmt = "Builder %s must have an action to build %s."

- raise UserError, fmt % (self.get_name(env or self.env),

- map(str,tlist))

- key = self.action.batch_key(env or self.env, tlist, slist)

- if key:

- try:

- executor = SCons.Executor.GetBatchExecutor(key)

- except KeyError:

- pass

- else:

- executor.add_batch(tlist, slist)

-

- if executor is None:

- executor = SCons.Executor.Executor(self.action, env, [],

- tlist, slist, executor_kw)

- if key:

- SCons.Executor.AddBatchExecutor(key, executor)

-

- # Now set up the relevant information in the target Nodes themselves.

- for t in tlist:

- t.cwd = env.fs.getcwd()

- t.builder_set(self)

- t.env_set(env)

- t.add_source(slist)

- t.set_executor(executor)

- t.set_explicit(self.is_explicit)

-

- return SCons.Node.NodeList(tlist)

-

- def __call__(self, env, target=None, source=None, chdir=_null, **kw):

- # We now assume that target and source are lists or None.

- # The caller (typically Environment.BuilderWrapper) is

- # responsible for converting any scalar values to lists.

- if chdir is _null:

- ekw = self.executor_kw

- else:

- ekw = self.executor_kw.copy()

- ekw['chdir'] = chdir

- if kw:

- if kw.has_key('srcdir'):

- def prependDirIfRelative(f, srcdir=kw['srcdir']):

- import os.path

- if SCons.Util.is_String(f) and not os.path.isabs(f):

- f = os.path.join(srcdir, f)

- return f

- if not SCons.Util.is_List(source):

- source = [source]

- source = map(prependDirIfRelative, source)

- del kw['srcdir']

- if self.overrides:

- env_kw = self.overrides.copy()

- env_kw.update(kw)

- else:

- env_kw = kw

- else:

- env_kw = self.overrides

- env = env.Override(env_kw)

- return self._execute(env, target, source, OverrideWarner(kw), ekw)

-

- def adjust_suffix(self, suff):

- if suff and not suff[0] in [ '.', '_', '$' ]:

- return '.' + suff

- return suff

-

- def get_prefix(self, env, sources=[]):

- prefix = self.prefix

- if callable(prefix):

- prefix = prefix(env, sources)

- return env.subst(prefix)

-

- def set_suffix(self, suffix):

- if not callable(suffix):

- suffix = self.adjust_suffix(suffix)

- self.suffix = suffix

-

- def get_suffix(self, env, sources=[]):

- suffix = self.suffix

- if callable(suffix):

- suffix = suffix(env, sources)

- return env.subst(suffix)

-

- def set_src_suffix(self, src_suffix):

- if not src_suffix:

- src_suffix = []

- elif not SCons.Util.is_List(src_suffix):

- src_suffix = [ src_suffix ]

- adjust = lambda suf, s=self: \

- callable(suf) and suf or s.adjust_suffix(suf)

- self.src_suffix = map(adjust, src_suffix)

-

- def get_src_suffix(self, env):

- """Get the first src_suffix in the list of src_suffixes."""

- ret = self.src_suffixes(env)

- if not ret:

- return ''

- return ret[0]

-

- def add_emitter(self, suffix, emitter):

- """Add a suffix-emitter mapping to this Builder.

-

- This assumes that emitter has been initialized with an

- appropriate dictionary type, and will throw a TypeError if

- not, so the caller is responsible for knowing that this is an

- appropriate method to call for the Builder in question.

- """

- self.emitter[suffix] = emitter

-

- def add_src_builder(self, builder):

- """

- Add a new Builder to the list of src_builders.

-

- This requires wiping out cached values so that the computed

- lists of source suffixes get re-calculated.

- """

- self._memo = {}

- self.src_builder.append(builder)

-

- def _get_sdict(self, env):

- """

- Returns a dictionary mapping all of the source suffixes of all

- src_builders of this Builder to the underlying Builder that

- should be called first.

-

- This dictionary is used for each target specified, so we save a

- lot of extra computation by memoizing it for each construction

- environment.

-

- Note that this is re-computed each time, not cached, because there

- might be changes to one of our source Builders (or one of their

- source Builders, and so on, and so on...) that we can't "see."

-

- The underlying methods we call cache their computed values,

- though, so we hope repeatedly aggregating them into a dictionary

- like this won't be too big a hit. We may need to look for a

- better way to do this if performance data show this has turned

- into a significant bottleneck.

- """

- sdict = {}

- for bld in self.get_src_builders(env):

- for suf in bld.src_suffixes(env):

- sdict[suf] = bld

- return sdict

-

- def src_builder_sources(self, env, source, overwarn={}):

- sdict = self._get_sdict(env)

-

- src_suffixes = self.src_suffixes(env)

-

- lengths = list(set(map(len, src_suffixes)))

-

- def match_src_suffix(name, src_suffixes=src_suffixes, lengths=lengths):

- node_suffixes = map(lambda l, n=name: n[-l:], lengths)

- for suf in src_suffixes:

- if suf in node_suffixes:

- return suf

- return None

-

- result = []

- for s in SCons.Util.flatten(source):

- if SCons.Util.is_String(s):

- match_suffix = match_src_suffix(env.subst(s))

- if not match_suffix and not '.' in s:

- src_suf = self.get_src_suffix(env)

- s = self._adjustixes(s, None, src_suf)[0]

- else:

- match_suffix = match_src_suffix(s.name)

- if match_suffix:

- try:

- bld = sdict[match_suffix]

- except KeyError:

- result.append(s)

- else:

- tlist = bld._execute(env, None, [s], overwarn)

- # If the subsidiary Builder returned more than one

- # target, then filter out any sources that this

- # Builder isn't capable of building.

- if len(tlist) > 1:

- mss = lambda t, m=match_src_suffix: m(t.name)

- tlist = filter(mss, tlist)

- result.extend(tlist)

- else:

- result.append(s)

-

- source_factory = env.get_factory(self.source_factory)

-

- return env.arg2nodes(result, source_factory)

-

- def _get_src_builders_key(self, env):

- return id(env)

-

- memoizer_counters.append(SCons.Memoize.CountDict('get_src_builders', _get_src_builders_key))

-

- def get_src_builders(self, env):

- """

- Returns the list of source Builders for this Builder.

-

- This exists mainly to look up Builders referenced as

- strings in the 'BUILDER' variable of the construction

- environment and cache the result.

- """

- memo_key = id(env)

- try:

- memo_dict = self._memo['get_src_builders']

- except KeyError:

- memo_dict = {}

- self._memo['get_src_builders'] = memo_dict

- else:

- try:

- return memo_dict[memo_key]

- except KeyError:

- pass

-

- builders = []

- for bld in self.src_builder:

- if SCons.Util.is_String(bld):

- try:

- bld = env['BUILDERS'][bld]

- except KeyError:

- continue

- builders.append(bld)

-

- memo_dict[memo_key] = builders

- return builders

-

- def _subst_src_suffixes_key(self, env):

- return id(env)

-

- memoizer_counters.append(SCons.Memoize.CountDict('subst_src_suffixes', _subst_src_suffixes_key))

-

- def subst_src_suffixes(self, env):

- """

- The suffix list may contain construction variable expansions,

- so we have to evaluate the individual strings. To avoid doing

- this over and over, we memoize the results for each construction

- environment.

- """

- memo_key = id(env)

- try:

- memo_dict = self._memo['subst_src_suffixes']

- except KeyError:

- memo_dict = {}

- self._memo['subst_src_suffixes'] = memo_dict

- else:

- try:

- return memo_dict[memo_key]

- except KeyError:

- pass

- suffixes = map(lambda x, s=self, e=env: e.subst(x), self.src_suffix)

- memo_dict[memo_key] = suffixes

- return suffixes

-

- def src_suffixes(self, env):

- """

- Returns the list of source suffixes for all src_builders of this

- Builder.

-

- This is essentially a recursive descent of the src_builder "tree."

- (This value isn't cached because there may be changes in a

- src_builder many levels deep that we can't see.)

- """

- sdict = {}

- suffixes = self.subst_src_suffixes(env)

- for s in suffixes:

- sdict[s] = 1

- for builder in self.get_src_builders(env):

- for s in builder.src_suffixes(env):

- if not sdict.has_key(s):

- sdict[s] = 1

- suffixes.append(s)

- return suffixes

-

-class CompositeBuilder(SCons.Util.Proxy):

- """A Builder Proxy whose main purpose is to always have

- a DictCmdGenerator as its action, and to provide access

- to the DictCmdGenerator's add_action() method.

- """

-

- def __init__(self, builder, cmdgen):

- if __debug__: logInstanceCreation(self, 'Builder.CompositeBuilder')

- SCons.Util.Proxy.__init__(self, builder)

-

- # cmdgen should always be an instance of DictCmdGenerator.

- self.cmdgen = cmdgen

- self.builder = builder

-

- def add_action(self, suffix, action):

- self.cmdgen.add_action(suffix, action)

- self.set_src_suffix(self.cmdgen.src_suffixes())

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

-#

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-__revision__ = "src/engine/SCons/CacheDir.py 4043 2009/02/23 09:06:45 scons"

-

-__doc__ = """

-CacheDir support

-"""

-

-import os.path

-import stat

-import string

-import sys

-

-import SCons.Action

-

-cache_enabled = True

-cache_debug = False

-cache_force = False

-cache_show = False

-

-def CacheRetrieveFunc(target, source, env):

- t = target[0]

- fs = t.fs

- cd = env.get_CacheDir()

- cachedir, cachefile = cd.cachepath(t)

- if not fs.exists(cachefile):

- cd.CacheDebug('CacheRetrieve(%s): %s not in cache\n', t, cachefile)

- return 1

- cd.CacheDebug('CacheRetrieve(%s): retrieving from %s\n', t, cachefile)

- if SCons.Action.execute_actions:

- if fs.islink(cachefile):

- fs.symlink(fs.readlink(cachefile), t.path)

- else:

- env.copy_from_cache(cachefile, t.path)

- st = fs.stat(cachefile)

- fs.chmod(t.path, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)

- return 0

-

-def CacheRetrieveString(target, source, env):

- t = target[0]

- fs = t.fs

- cd = env.get_CacheDir()

- cachedir, cachefile = cd.cachepath(t)

- if t.fs.exists(cachefile):

- return "Retrieved `%s' from cache" % t.path

- return None

-

-CacheRetrieve = SCons.Action.Action(CacheRetrieveFunc, CacheRetrieveString)

-

-CacheRetrieveSilent = SCons.Action.Action(CacheRetrieveFunc, None)

-

-def CachePushFunc(target, source, env):

- t = target[0]

- if t.nocache:

- return

- fs = t.fs

- cd = env.get_CacheDir()

- cachedir, cachefile = cd.cachepath(t)

- if fs.exists(cachefile):

- # Don't bother copying it if it's already there. Note that

- # usually this "shouldn't happen" because if the file already

- # existed in cache, we'd have retrieved the file from there,

- # not built it. This can happen, though, in a race, if some

- # other person running the same build pushes their copy to

- # the cache after we decide we need to build it but before our

- # build completes.

- cd.CacheDebug('CachePush(%s): %s already exists in cache\n', t, cachefile)

- return

-

- cd.CacheDebug('CachePush(%s): pushing to %s\n', t, cachefile)

-

- tempfile = cachefile+'.tmp'+str(os.getpid())

- errfmt = "Unable to copy %s to cache. Cache file is %s"

-

- if not fs.isdir(cachedir):

- try:

- fs.makedirs(cachedir)

- except EnvironmentError:

- # We may have received an exception because another process

- # has beaten us creating the directory.

- if not fs.isdir(cachedir):

- msg = errfmt % (str(target), cachefile)

- raise SCons.Errors.EnvironmentError, msg

-

- try:

- if fs.islink(t.path):

- fs.symlink(fs.readlink(t.path), tempfile)

- else:

- fs.copy2(t.path, tempfile)

- fs.rename(tempfile, cachefile)

- st = fs.stat(t.path)

- fs.chmod(cachefile, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)

- except EnvironmentError:

- # It's possible someone else tried writing the file at the

- # same time we did, or else that there was some problem like

- # the CacheDir being on a separate file system that's full.

- # In any case, inability to push a file to cache doesn't affect

- # the correctness of the build, so just print a warning.

- msg = errfmt % (str(target), cachefile)

- SCons.Warnings.warn(SCons.Warnings.CacheWriteErrorWarning, msg)

-

-CachePush = SCons.Action.Action(CachePushFunc, None)

-

-class CacheDir:

-

- def __init__(self, path):

- try:

- import hashlib

- except ImportError:

- msg = "No hashlib or MD5 module available, CacheDir() not supported"

- SCons.Warnings.warn(SCons.Warnings.NoMD5ModuleWarning, msg)

- self.path = None

- else:

- self.path = path

- self.current_cache_debug = None

- self.debugFP = None

-

- def CacheDebug(self, fmt, target, cachefile):

- if cache_debug != self.current_cache_debug:

- if cache_debug == '-':

- self.debugFP = sys.stdout

- elif cache_debug:

- self.debugFP = open(cache_debug, 'w')

- else:

- self.debugFP = None

- self.current_cache_debug = cache_debug

- if self.debugFP:

- self.debugFP.write(fmt % (target, os.path.split(cachefile)[1]))

-

- def is_enabled(self):

- return (cache_enabled and not self.path is None)

-

- def cachepath(self, node):

- """

- """

- if not self.is_enabled():

- return None, None

-

- sig = node.get_cachedir_bsig()

- subdir = string.upper(sig[0])

- dir = os.path.join(self.path, subdir)

- return dir, os.path.join(dir, sig)

-

- def retrieve(self, node):

- """

- This method is called from multiple threads in a parallel build,

- so only do thread safe stuff here. Do thread unsafe stuff in

- built().

-

- Note that there's a special trick here with the execute flag

- (one that's not normally done for other actions). Basically

- if the user requested a no_exec (-n) build, then

- SCons.Action.execute_actions is set to 0 and when any action

- is called, it does its showing but then just returns zero

- instead of actually calling the action execution operation.

- The problem for caching is that if the file does NOT exist in

- cache then the CacheRetrieveString won't return anything to

- show for the task, but the Action.__call__ won't call

- CacheRetrieveFunc; instead it just returns zero, which makes

- the code below think that the file *was* successfully

- retrieved from the cache, therefore it doesn't do any

- subsequent building. However, the CacheRetrieveString didn't

- print anything because it didn't actually exist in the cache,

- and no more build actions will be performed, so the user just

- sees nothing. The fix is to tell Action.__call__ to always

- execute the CacheRetrieveFunc and then have the latter

- explicitly check SCons.Action.execute_actions itself.

- """

- if not self.is_enabled():

- return False

-

- env = node.get_build_env()

- if cache_show:

- if CacheRetrieveSilent(node, [], env, execute=1) == 0:

- node.build(presub=0, execute=0)

- return True

- else:

- if CacheRetrieve(node, [], env, execute=1) == 0:

- return True

-

- return False

-

- def push(self, node):

- if not self.is_enabled():

- return

- return CachePush(node, [], node.get_build_env())

-

- def push_if_forced(self, node):

- if cache_force:

- return self.push(node)

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

-"""SCons.Conftest

-

-Autoconf-like configuration support; low level implementation of tests.

-"""

-

-#

-# Copyright (c) 2003 Stichting NLnet Labs

-# Copyright (c) 2001, 2002, 2003 Steven Knight

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-#

-# The purpose of this module is to define how a check is to be performed.

-# Use one of the Check...() functions below.

-#

-

-#

-# A context class is used that defines functions for carrying out the tests,

-# logging and messages. The following methods and members must be present:

-#

-# context.Display(msg) Function called to print messages that are normally

-# displayed for the user. Newlines are explicitly used.

-# The text should also be written to the logfile!

-#

-# context.Log(msg) Function called to write to a log file.

-#

-# context.BuildProg(text, ext)

-# Function called to build a program, using "ext" for the

-# file extention. Must return an empty string for

-# success, an error message for failure.

-# For reliable test results building should be done just

-# like an actual program would be build, using the same

-# command and arguments (including configure results so

-# far).

-#

-# context.CompileProg(text, ext)

-# Function called to compile a program, using "ext" for

-# the file extention. Must return an empty string for

-# success, an error message for failure.

-# For reliable test results compiling should be done just

-# like an actual source file would be compiled, using the

-# same command and arguments (including configure results

-# so far).

-#

-# context.AppendLIBS(lib_name_list)

-# Append "lib_name_list" to the value of LIBS.

-# "lib_namelist" is a list of strings.

-# Return the value of LIBS before changing it (any type

-# can be used, it is passed to SetLIBS() later.

-#

-# context.SetLIBS(value)

-# Set LIBS to "value". The type of "value" is what

-# AppendLIBS() returned.

-# Return the value of LIBS before changing it (any type

-# can be used, it is passed to SetLIBS() later.

-#

-# context.headerfilename

-# Name of file to append configure results to, usually

-# "confdefs.h".

-# The file must not exist or be empty when starting.

-# Empty or None to skip this (some tests will not work!).

-#

-# context.config_h (may be missing). If present, must be a string, which

-# will be filled with the contents of a config_h file.

-#

-# context.vardict Dictionary holding variables used for the tests and

-# stores results from the tests, used for the build

-# commands.

-# Normally contains "CC", "LIBS", "CPPFLAGS", etc.

-#

-# context.havedict Dictionary holding results from the tests that are to

-# be used inside a program.

-# Names often start with "HAVE_". These are zero

-# (feature not present) or one (feature present). Other

-# variables may have any value, e.g., "PERLVERSION" can

-# be a number and "SYSTEMNAME" a string.

-#

-

-import re

-import string

-from types import IntType

-

-#

-# PUBLIC VARIABLES

-#

-

-LogInputFiles = 1 # Set that to log the input files in case of a failed test

-LogErrorMessages = 1 # Set that to log Conftest-generated error messages

-

-#

-# PUBLIC FUNCTIONS

-#

-

-# Generic remarks:

-# - When a language is specified which is not supported the test fails. The

-# message is a bit different, because not all the arguments for the normal

-# message are available yet (chicken-egg problem).

-

-

-def CheckBuilder(context, text = None, language = None):

- """

- Configure check to see if the compiler works.

- Note that this uses the current value of compiler and linker flags, make

- sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.

- "language" should be "C" or "C++" and is used to select the compiler.

- Default is "C".

- "text" may be used to specify the code to be build.

- Returns an empty string for success, an error message for failure.

- """

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("%s\n" % msg)

- return msg

-

- if not text:

- text = """

-int main() {

- return 0;

-}

-"""

-

- context.Display("Checking if building a %s file works... " % lang)

- ret = context.BuildProg(text, suffix)

- _YesNoResult(context, ret, None, text)

- return ret

-

-def CheckCC(context):

- """

- Configure check for a working C compiler.

-

- This checks whether the C compiler, as defined in the $CC construction

- variable, can compile a C source file. It uses the current $CCCOM value

- too, so that it can test against non working flags.

-

- """

- context.Display("Checking whether the C compiler works")

- text = """

-int main()

-{

- return 0;

-}

-"""

- ret = _check_empty_program(context, 'CC', text, 'C')

- _YesNoResult(context, ret, None, text)

- return ret

-

-def CheckSHCC(context):

- """

- Configure check for a working shared C compiler.

-

- This checks whether the C compiler, as defined in the $SHCC construction

- variable, can compile a C source file. It uses the current $SHCCCOM value

- too, so that it can test against non working flags.

-

- """

- context.Display("Checking whether the (shared) C compiler works")

- text = """

-int foo()

-{

- return 0;

-}

-"""

- ret = _check_empty_program(context, 'SHCC', text, 'C', use_shared = True)

- _YesNoResult(context, ret, None, text)

- return ret

-

-def CheckCXX(context):

- """

- Configure check for a working CXX compiler.

-

- This checks whether the CXX compiler, as defined in the $CXX construction

- variable, can compile a CXX source file. It uses the current $CXXCOM value

- too, so that it can test against non working flags.

-

- """

- context.Display("Checking whether the C++ compiler works")

- text = """

-int main()

-{

- return 0;

-}

-"""

- ret = _check_empty_program(context, 'CXX', text, 'C++')

- _YesNoResult(context, ret, None, text)

- return ret

-

-def CheckSHCXX(context):

- """

- Configure check for a working shared CXX compiler.

-

- This checks whether the CXX compiler, as defined in the $SHCXX construction

- variable, can compile a CXX source file. It uses the current $SHCXXCOM value

- too, so that it can test against non working flags.

-

- """

- context.Display("Checking whether the (shared) C++ compiler works")

- text = """

-int main()

-{

- return 0;

-}

-"""

- ret = _check_empty_program(context, 'SHCXX', text, 'C++', use_shared = True)

- _YesNoResult(context, ret, None, text)

- return ret

-

-def _check_empty_program(context, comp, text, language, use_shared = False):

- """Return 0 on success, 1 otherwise."""

- if not context.env.has_key(comp) or not context.env[comp]:

- # The compiler construction variable is not set or empty

- return 1

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- return 1

-

- if use_shared:

- return context.CompileSharedObject(text, suffix)

- else:

- return context.CompileProg(text, suffix)

-

-

-def CheckFunc(context, function_name, header = None, language = None):

- """

- Configure check for a function "function_name".

- "language" should be "C" or "C++" and is used to select the compiler.

- Default is "C".

- Optional "header" can be defined to define a function prototype, include a

- header file or anything else that comes before main().

- Sets HAVE_function_name in context.havedict according to the result.

- Note that this uses the current value of compiler and linker flags, make

- sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.

- Returns an empty string for success, an error message for failure.

- """

-

- # Remarks from autoconf:

- # - Don't include <ctype.h> because on OSF/1 3.0 it includes <sys/types.h>

- # which includes <sys/select.h> which contains a prototype for select.

- # Similarly for bzero.

- # - assert.h is included to define __stub macros and hopefully few

- # prototypes, which can conflict with char $1(); below.

- # - Override any gcc2 internal prototype to avoid an error.

- # - We use char for the function declaration because int might match the

- # return type of a gcc2 builtin and then its argument prototype would

- # still apply.

- # - The GNU C library defines this for functions which it implements to

- # always fail with ENOSYS. Some functions are actually named something

- # starting with __ and the normal name is an alias.

-

- if context.headerfilename:

- includetext = '#include "%s"' % context.headerfilename

- else:

- includetext = ''

- if not header:

- header = """

-#ifdef __cplusplus

-extern "C"

-#endif

-char %s();""" % function_name

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("Cannot check for %s(): %s\n" % (function_name, msg))

- return msg

-

- text = """

-%(include)s

-#include <assert.h>

-%(hdr)s

-

-int main() {

-#if defined (__stub_%(name)s) || defined (__stub___%(name)s)

- fail fail fail

-#else

- %(name)s();

-#endif

-

- return 0;

-}

-""" % { 'name': function_name,

- 'include': includetext,

- 'hdr': header }

-

- context.Display("Checking for %s function %s()... " % (lang, function_name))

- ret = context.BuildProg(text, suffix)

- _YesNoResult(context, ret, "HAVE_" + function_name, text,

- "Define to 1 if the system has the function `%s'." %\

- function_name)

- return ret

-

-

-def CheckHeader(context, header_name, header = None, language = None,

- include_quotes = None):

- """

- Configure check for a C or C++ header file "header_name".

- Optional "header" can be defined to do something before including the

- header file (unusual, supported for consistency).

- "language" should be "C" or "C++" and is used to select the compiler.

- Default is "C".

- Sets HAVE_header_name in context.havedict according to the result.

- Note that this uses the current value of compiler and linker flags, make

- sure $CFLAGS and $CPPFLAGS are set correctly.

- Returns an empty string for success, an error message for failure.

- """

- # Why compile the program instead of just running the preprocessor?

- # It is possible that the header file exists, but actually using it may

- # fail (e.g., because it depends on other header files). Thus this test is

- # more strict. It may require using the "header" argument.

- #

- # Use <> by default, because the check is normally used for system header

- # files. SCons passes '""' to overrule this.

-

- # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.

- if context.headerfilename:

- includetext = '#include "%s"\n' % context.headerfilename

- else:

- includetext = ''

- if not header:

- header = ""

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("Cannot check for header file %s: %s\n"

- % (header_name, msg))

- return msg

-

- if not include_quotes:

- include_quotes = "<>"

-

- text = "%s%s\n#include %s%s%s\n\n" % (includetext, header,

- include_quotes[0], header_name, include_quotes[1])

-

- context.Display("Checking for %s header file %s... " % (lang, header_name))

- ret = context.CompileProg(text, suffix)

- _YesNoResult(context, ret, "HAVE_" + header_name, text,

- "Define to 1 if you have the <%s> header file." % header_name)

- return ret

-

-

-def CheckType(context, type_name, fallback = None,

- header = None, language = None):

- """

- Configure check for a C or C++ type "type_name".

- Optional "header" can be defined to include a header file.

- "language" should be "C" or "C++" and is used to select the compiler.

- Default is "C".

- Sets HAVE_type_name in context.havedict according to the result.

- Note that this uses the current value of compiler and linker flags, make

- sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.

- Returns an empty string for success, an error message for failure.

- """

-

- # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.

- if context.headerfilename:

- includetext = '#include "%s"' % context.headerfilename

- else:

- includetext = ''

- if not header:

- header = ""

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("Cannot check for %s type: %s\n" % (type_name, msg))

- return msg

-

- # Remarks from autoconf about this test:

- # - Grepping for the type in include files is not reliable (grep isn't

- # portable anyway).

- # - Using "TYPE my_var;" doesn't work for const qualified types in C++.

- # Adding an initializer is not valid for some C++ classes.

- # - Using the type as parameter to a function either fails for K&$ C or for

- # C++.

- # - Using "TYPE *my_var;" is valid in C for some types that are not

- # declared (struct something).

- # - Using "sizeof(TYPE)" is valid when TYPE is actually a variable.

- # - Using the previous two together works reliably.

- text = """

-%(include)s

-%(header)s

-

-int main() {

- if ((%(name)s *) 0)

- return 0;

- if (sizeof (%(name)s))

- return 0;

-}

-""" % { 'include': includetext,

- 'header': header,

- 'name': type_name }

-

- context.Display("Checking for %s type %s... " % (lang, type_name))

- ret = context.BuildProg(text, suffix)

- _YesNoResult(context, ret, "HAVE_" + type_name, text,

- "Define to 1 if the system has the type `%s'." % type_name)

- if ret and fallback and context.headerfilename:

- f = open(context.headerfilename, "a")

- f.write("typedef %s %s;\n" % (fallback, type_name))

- f.close()

-

- return ret

-

-def CheckTypeSize(context, type_name, header = None, language = None, expect = None):

- """This check can be used to get the size of a given type, or to check whether

- the type is of expected size.

-

- Arguments:

- - type : str

- the type to check

- - includes : sequence

- list of headers to include in the test code before testing the type

- - language : str

- 'C' or 'C++'

- - expect : int

- if given, will test wether the type has the given number of bytes.

- If not given, will automatically find the size.

-

- Returns:

- status : int

- 0 if the check failed, or the found size of the type if the check succeeded."""

-

- # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.

- if context.headerfilename:

- includetext = '#include "%s"' % context.headerfilename

- else:

- includetext = ''

-

- if not header:

- header = ""

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("Cannot check for %s type: %s\n" % (type_name, msg))

- return msg

-

- src = includetext + header

- if not expect is None:

- # Only check if the given size is the right one

- context.Display('Checking %s is %d bytes... ' % (type_name, expect))

-

- # test code taken from autoconf: this is a pretty clever hack to find that

- # a type is of a given size using only compilation. This speeds things up

- # quite a bit compared to straightforward code using TryRun

- src = src + r"""

-typedef %s scons_check_type;

-

-int main()

-{

- static int test_array[1 - 2 * !(((long int) (sizeof(scons_check_type))) == %d)];

- test_array[0] = 0;

-

- return 0;

-}

-"""

-

- st = context.CompileProg(src % (type_name, expect), suffix)

- if not st:

- context.Display("yes\n")

- _Have(context, "SIZEOF_%s" % type_name, expect,

- "The size of `%s', as computed by sizeof." % type_name)

- return expect

- else:

- context.Display("no\n")

- _LogFailed(context, src, st)

- return 0

- else:

- # Only check if the given size is the right one

- context.Message('Checking size of %s ... ' % type_name)

-

- # We have to be careful with the program we wish to test here since

- # compilation will be attempted using the current environment's flags.

- # So make sure that the program will compile without any warning. For

- # example using: 'int main(int argc, char** argv)' will fail with the

- # '-Wall -Werror' flags since the variables argc and argv would not be

- # used in the program...

- #

- src = src + """

-#include <stdlib.h>

-#include <stdio.h>

-int main() {

- printf("%d", (int)sizeof(""" + type_name + """));

- return 0;

-}

- """

- st, out = context.RunProg(src, suffix)

- try:

- size = int(out)

- except ValueError:

- # If cannot convert output of test prog to an integer (the size),

- # something went wront, so just fail

- st = 1

- size = 0

-

- if not st:

- context.Display("yes\n")

- _Have(context, "SIZEOF_%s" % type_name, size,

- "The size of `%s', as computed by sizeof." % type_name)

- return size

- else:

- context.Display("no\n")

- _LogFailed(context, src, st)

- return 0

-

- return 0

-

-def CheckDeclaration(context, symbol, includes = None, language = None):

- """Checks whether symbol is declared.

-

- Use the same test as autoconf, that is test whether the symbol is defined

- as a macro or can be used as an r-value.

-

- Arguments:

- symbol : str

- the symbol to check

- includes : str

- Optional "header" can be defined to include a header file.

- language : str

- only C and C++ supported.

-

- Returns:

- status : bool

- True if the check failed, False if succeeded."""

-

- # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.

- if context.headerfilename:

- includetext = '#include "%s"' % context.headerfilename

- else:

- includetext = ''

-

- if not includes:

- includes = ""

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("Cannot check for declaration %s: %s\n" % (type_name, msg))

- return msg

-

- src = includetext + includes

- context.Display('Checking whether %s is declared... ' % symbol)

-

- src = src + r"""

-int main()

-{

-#ifndef %s

- (void) %s;

-#endif

- ;

- return 0;

-}

-""" % (symbol, symbol)

-

- st = context.CompileProg(src, suffix)

- _YesNoResult(context, st, "HAVE_DECL_" + symbol, src,

- "Set to 1 if %s is defined." % symbol)

- return st

-

-def CheckLib(context, libs, func_name = None, header = None,

- extra_libs = None, call = None, language = None, autoadd = 1):

- """

- Configure check for a C or C++ libraries "libs". Searches through

- the list of libraries, until one is found where the test succeeds.

- Tests if "func_name" or "call" exists in the library. Note: if it exists

- in another library the test succeeds anyway!

- Optional "header" can be defined to include a header file. If not given a

- default prototype for "func_name" is added.

- Optional "extra_libs" is a list of library names to be added after

- "lib_name" in the build command. To be used for libraries that "lib_name"

- depends on.

- Optional "call" replaces the call to "func_name" in the test code. It must

- consist of complete C statements, including a trailing ";".

- Both "func_name" and "call" arguments are optional, and in that case, just

- linking against the libs is tested.

- "language" should be "C" or "C++" and is used to select the compiler.

- Default is "C".

- Note that this uses the current value of compiler and linker flags, make

- sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.

- Returns an empty string for success, an error message for failure.

- """

- # Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.

- if context.headerfilename:

- includetext = '#include "%s"' % context.headerfilename

- else:

- includetext = ''

- if not header:

- header = ""

-

- text = """

-%s

-%s""" % (includetext, header)

-

- # Add a function declaration if needed.

- if func_name and func_name != "main":

- if not header:

- text = text + """

-#ifdef __cplusplus

-extern "C"

-#endif

-char %s();

-""" % func_name

-

- # The actual test code.

- if not call:

- call = "%s();" % func_name

-

- # if no function to test, leave main() blank

- text = text + """

-int

-main() {

- %s

-return 0;

-}

-""" % (call or "")

-

- if call:

- i = string.find(call, "\n")

- if i > 0:

- calltext = call[:i] + ".."

- elif call[-1] == ';':

- calltext = call[:-1]

- else:

- calltext = call

-

- for lib_name in libs:

-

- lang, suffix, msg = _lang2suffix(language)

- if msg:

- context.Display("Cannot check for library %s: %s\n" % (lib_name, msg))

- return msg

-

- # if a function was specified to run in main(), say it

- if call:

- context.Display("Checking for %s in %s library %s... "

- % (calltext, lang, lib_name))

- # otherwise, just say the name of library and language

- else:

- context.Display("Checking for %s library %s... "

- % (lang, lib_name))

-

- if lib_name:

- l = [ lib_name ]

- if extra_libs:

- l.extend(extra_libs)

- oldLIBS = context.AppendLIBS(l)

- sym = "HAVE_LIB" + lib_name

- else:

- oldLIBS = -1

- sym = None

-

- ret = context.BuildProg(text, suffix)

-

- _YesNoResult(context, ret, sym, text,

- "Define to 1 if you have the `%s' library." % lib_name)

- if oldLIBS != -1 and (ret or not autoadd):

- context.SetLIBS(oldLIBS)

-

- if not ret:

- return ret

-

- return ret

-

-#

-# END OF PUBLIC FUNCTIONS

-#

-

-def _YesNoResult(context, ret, key, text, comment = None):

- """

- Handle the result of a test with a "yes" or "no" result.

- "ret" is the return value: empty if OK, error message when not.

- "key" is the name of the symbol to be defined (HAVE_foo).

- "text" is the source code of the program used for testing.

- "comment" is the C comment to add above the line defining the symbol (the

- comment is automatically put inside a /* */). If None, no comment is added.

- """

- if key:

- _Have(context, key, not ret, comment)

- if ret:

- context.Display("no\n")

- _LogFailed(context, text, ret)

- else:

- context.Display("yes\n")

-

-

-def _Have(context, key, have, comment = None):

- """

- Store result of a test in context.havedict and context.headerfilename.

- "key" is a "HAVE_abc" name. It is turned into all CAPITALS and non-

- alphanumerics are replaced by an underscore.

- The value of "have" can be:

- 1 - Feature is defined, add "#define key".

- 0 - Feature is not defined, add "/* #undef key */".

- Adding "undef" is what autoconf does. Not useful for the

- compiler, but it shows that the test was done.

- number - Feature is defined to this number "#define key have".

- Doesn't work for 0 or 1, use a string then.

- string - Feature is defined to this string "#define key have".

- Give "have" as is should appear in the header file, include quotes

- when desired and escape special characters!

- """

- key_up = string.upper(key)

- key_up = re.sub('[^A-Z0-9_]', '_', key_up)

- context.havedict[key_up] = have

- if have == 1:

- line = "#define %s 1\n" % key_up

- elif have == 0:

- line = "/* #undef %s */\n" % key_up

- elif type(have) == IntType:

- line = "#define %s %d\n" % (key_up, have)

- else:

- line = "#define %s %s\n" % (key_up, str(have))

-

- if comment is not None:

- lines = "\n/* %s */\n" % comment + line

- else:

- lines = "\n" + line

-

- if context.headerfilename:

- f = open(context.headerfilename, "a")

- f.write(lines)

- f.close()

- elif hasattr(context,'config_h'):

- context.config_h = context.config_h + lines

-

-

-def _LogFailed(context, text, msg):

- """

- Write to the log about a failed program.

- Add line numbers, so that error messages can be understood.

- """

- if LogInputFiles:

- context.Log("Failed program was:\n")

- lines = string.split(text, '\n')

- if len(lines) and lines[-1] == '':

- lines = lines[:-1] # remove trailing empty line

- n = 1

- for line in lines:

- context.Log("%d: %s\n" % (n, line))

- n = n + 1

- if LogErrorMessages:

- context.Log("Error message: %s\n" % msg)

-

-

-def _lang2suffix(lang):

- """

- Convert a language name to a suffix.

- When "lang" is empty or None C is assumed.

- Returns a tuple (lang, suffix, None) when it works.

- For an unrecognized language returns (None, None, msg).

- Where:

- lang = the unified language name

- suffix = the suffix, including the leading dot

- msg = an error message

- """

- if not lang or lang in ["C", "c"]:

- return ("C", ".c", None)

- if lang in ["c++", "C++", "cpp", "CXX", "cxx"]:

- return ("C++", ".cpp", None)

-

- return None, None, "Unsupported language: %s" % lang

-

-

-# vim: set sw=4 et sts=4 tw=79 fo+=l:

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

-"""SCons.Debug

-

-Code for debugging SCons internal things. Not everything here is

-guaranteed to work all the way back to Python 1.5.2, and shouldn't be

-needed by most users.

-

-"""

-

-#

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-__revision__ = "src/engine/SCons/Debug.py 4043 2009/02/23 09:06:45 scons"

-

-import os

-import string

-import sys

-

-# Recipe 14.10 from the Python Cookbook.

-try:

- import weakref

-except ImportError:

- def logInstanceCreation(instance, name=None):

- pass

-else:

- def logInstanceCreation(instance, name=None):

- if name is None:

- name = instance.__class__.__name__

- if not tracked_classes.has_key(name):

- tracked_classes[name] = []

- tracked_classes[name].append(weakref.ref(instance))

-

-

-

-tracked_classes = {}

-

-def string_to_classes(s):

- if s == '*':

- c = tracked_classes.keys()

- c.sort()

- return c

- else:

- return string.split(s)

-

-def fetchLoggedInstances(classes="*"):

- classnames = string_to_classes(classes)

- return map(lambda cn: (cn, len(tracked_classes[cn])), classnames)

-

-def countLoggedInstances(classes, file=sys.stdout):

- for classname in string_to_classes(classes):

- file.write("%s: %d\n" % (classname, len(tracked_classes[classname])))

-

-def listLoggedInstances(classes, file=sys.stdout):

- for classname in string_to_classes(classes):

- file.write('\n%s:\n' % classname)

- for ref in tracked_classes[classname]:

- obj = ref()

- if obj is not None:

- file.write(' %s\n' % repr(obj))

-

-def dumpLoggedInstances(classes, file=sys.stdout):

- for classname in string_to_classes(classes):

- file.write('\n%s:\n' % classname)

- for ref in tracked_classes[classname]:

- obj = ref()

- if obj is not None:

- file.write(' %s:\n' % obj)

- for key, value in obj.__dict__.items():

- file.write(' %20s : %s\n' % (key, value))

-

-

-

-if sys.platform[:5] == "linux":

- # Linux doesn't actually support memory usage stats from getrusage().

- def memory():

- mstr = open('/proc/self/stat').read()

- mstr = string.split(mstr)[22]

- return int(mstr)

-else:

- try:

- import resource

- except ImportError:

- try:

- import win32process

- import win32api

- except ImportError:

- def memory():

- return 0

- else:

- def memory():

- process_handle = win32api.GetCurrentProcess()

- memory_info = win32process.GetProcessMemoryInfo( process_handle )

- return memory_info['PeakWorkingSetSize']

- else:

- def memory():

- res = resource.getrusage(resource.RUSAGE_SELF)

- return res[4]

-

-# returns caller's stack

-def caller_stack(*backlist):

- import traceback

- if not backlist:

- backlist = [0]

- result = []

- for back in backlist:

- tb = traceback.extract_stack(limit=3+back)

- key = tb[0][:3]

- result.append('%s:%d(%s)' % func_shorten(key))

- return result

-

-caller_bases = {}

-caller_dicts = {}

-

-# trace a caller's stack

-def caller_trace(back=0):

- import traceback

- tb = traceback.extract_stack(limit=3+back)

- tb.reverse()

- callee = tb[1][:3]

- caller_bases[callee] = caller_bases.get(callee, 0) + 1

- for caller in tb[2:]:

- caller = callee + caller[:3]

- try:

- entry = caller_dicts[callee]

- except KeyError:

- caller_dicts[callee] = entry = {}

- entry[caller] = entry.get(caller, 0) + 1

- callee = caller

-

-# print a single caller and its callers, if any

-def _dump_one_caller(key, file, level=0):

- l = []

- for c,v in caller_dicts[key].items():

- l.append((-v,c))

- l.sort()

- leader = ' '*level

- for v,c in l:

- file.write("%s %6d %s:%d(%s)\n" % ((leader,-v) + func_shorten(c[-3:])))

- if caller_dicts.has_key(c):

- _dump_one_caller(c, file, level+1)

-

-# print each call tree

-def dump_caller_counts(file=sys.stdout):

- keys = caller_bases.keys()

- keys.sort()

- for k in keys:

- file.write("Callers of %s:%d(%s), %d calls:\n"

- % (func_shorten(k) + (caller_bases[k],)))

- _dump_one_caller(k, file)

-

-shorten_list = [

- ( '/scons/SCons/', 1),

- ( '/src/engine/SCons/', 1),

- ( '/usr/lib/python', 0),

-]

-

-if os.sep != '/':

- def platformize(t):

- return (string.replace(t[0], '/', os.sep), t[1])

- shorten_list = map(platformize, shorten_list)

- del platformize

-

-def func_shorten(func_tuple):

- f = func_tuple[0]

- for t in shorten_list:

- i = string.find(f, t[0])

- if i >= 0:

- if t[1]:

- i = i + len(t[0])

- return (f[i:],)+func_tuple[1:]

- return func_tuple

-

-

-TraceFP = {}

-if sys.platform == 'win32':

- TraceDefault = 'con'

-else:

- TraceDefault = '/dev/tty'

-

-def Trace(msg, file=None, mode='w'):

- """Write a trace message to a file. Whenever a file is specified,

- it becomes the default for the next call to Trace()."""

- global TraceDefault

- if file is None:

- file = TraceDefault

- else:

- TraceDefault = file

- try:

- fp = TraceFP[file]

- except KeyError:

- try:

- fp = TraceFP[file] = open(file, mode)

- except TypeError:

- # Assume we were passed an open file pointer.

- fp = file

- fp.write(msg)

- fp.flush()

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

-"""SCons.Defaults

-

-Builders and other things for the local site. Here's where we'll

-duplicate the functionality of autoconf until we move it into the

-installation procedure or use something like qmconf.

-

-The code that reads the registry to find MSVC components was borrowed

-from distutils.msvccompiler.

-

-"""

-

-#

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-__revision__ = "src/engine/SCons/Defaults.py 4043 2009/02/23 09:06:45 scons"

-

-

-

-import os

-import os.path

-import errno

-import shutil

-import stat

-import string

-import time

-import types

-import sys

-

-import SCons.Action

-import SCons.Builder

-import SCons.CacheDir

-import SCons.Environment

-import SCons.PathList

-import SCons.Subst

-import SCons.Tool

-

-# A placeholder for a default Environment (for fetching source files

-# from source code management systems and the like). This must be

-# initialized later, after the top-level directory is set by the calling

-# interface.

-_default_env = None

-

-# Lazily instantiate the default environment so the overhead of creating

-# it doesn't apply when it's not needed.

-def _fetch_DefaultEnvironment(*args, **kw):

- """

- Returns the already-created default construction environment.

- """

- global _default_env

- return _default_env

-

-def DefaultEnvironment(*args, **kw):

- """

- Initial public entry point for creating the default construction

- Environment.

-

- After creating the environment, we overwrite our name

- (DefaultEnvironment) with the _fetch_DefaultEnvironment() function,

- which more efficiently returns the initialized default construction

- environment without checking for its existence.

-

- (This function still exists with its _default_check because someone

- else (*cough* Script/__init__.py *cough*) may keep a reference

- to this function. So we can't use the fully functional idiom of

- having the name originally be a something that *only* creates the

- construction environment and then overwrites the name.)

- """

- global _default_env

- if not _default_env:

- import SCons.Util

- _default_env = apply(SCons.Environment.Environment, args, kw)

- if SCons.Util.md5:

- _default_env.Decider('MD5')

- else:

- _default_env.Decider('timestamp-match')

- global DefaultEnvironment

- DefaultEnvironment = _fetch_DefaultEnvironment

- _default_env._CacheDir_path = None

- return _default_env

-

-# Emitters for setting the shared attribute on object files,

-# and an action for checking that all of the source files

-# going into a shared library are, in fact, shared.

-def StaticObjectEmitter(target, source, env):

- for tgt in target:

- tgt.attributes.shared = None

- return (target, source)

-

-def SharedObjectEmitter(target, source, env):

- for tgt in target:

- tgt.attributes.shared = 1

- return (target, source)

-

-def SharedFlagChecker(source, target, env):

- same = env.subst('$STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME')

- if same == '0' or same == '' or same == 'False':

- for src in source:

- try:

- shared = src.attributes.shared

- except AttributeError:

- shared = None

- if not shared:

- raise SCons.Errors.UserError, "Source file: %s is static and is not compatible with shared target: %s" % (src, target[0])

-

-SharedCheck = SCons.Action.Action(SharedFlagChecker, None)

-

-# Some people were using these variable name before we made

-# SourceFileScanner part of the public interface. Don't break their

-# SConscript files until we've given them some fair warning and a

-# transition period.

-CScan = SCons.Tool.CScanner

-DScan = SCons.Tool.DScanner

-LaTeXScan = SCons.Tool.LaTeXScanner

-ObjSourceScan = SCons.Tool.SourceFileScanner

-ProgScan = SCons.Tool.ProgramScanner

-

-# These aren't really tool scanners, so they don't quite belong with

-# the rest of those in Tool/__init__.py, but I'm not sure where else

-# they should go. Leave them here for now.

-import SCons.Scanner.Dir

-DirScanner = SCons.Scanner.Dir.DirScanner()

-DirEntryScanner = SCons.Scanner.Dir.DirEntryScanner()

-

-# Actions for common languages.

-CAction = SCons.Action.Action("$CCCOM", "$CCCOMSTR")

-ShCAction = SCons.Action.Action("$SHCCCOM", "$SHCCCOMSTR")

-CXXAction = SCons.Action.Action("$CXXCOM", "$CXXCOMSTR")

-ShCXXAction = SCons.Action.Action("$SHCXXCOM", "$SHCXXCOMSTR")

-

-ASAction = SCons.Action.Action("$ASCOM", "$ASCOMSTR")

-ASPPAction = SCons.Action.Action("$ASPPCOM", "$ASPPCOMSTR")

-

-LinkAction = SCons.Action.Action("$LINKCOM", "$LINKCOMSTR")

-ShLinkAction = SCons.Action.Action("$SHLINKCOM", "$SHLINKCOMSTR")

-

-LdModuleLinkAction = SCons.Action.Action("$LDMODULECOM", "$LDMODULECOMSTR")

-

-# Common tasks that we allow users to perform in platform-independent

-# ways by creating ActionFactory instances.

-ActionFactory = SCons.Action.ActionFactory

-

-def get_paths_str(dest):

- # If dest is a list, we need to manually call str() on each element

- if SCons.Util.is_List(dest):

- elem_strs = []

- for element in dest:

- elem_strs.append('"' + str(element) + '"')

- return '[' + string.join(elem_strs, ', ') + ']'

- else:

- return '"' + str(dest) + '"'

-

-def chmod_func(dest, mode):

- SCons.Node.FS.invalidate_node_memos(dest)

- if not SCons.Util.is_List(dest):

- dest = [dest]

- for element in dest:

- os.chmod(str(element), mode)

-

-def chmod_strfunc(dest, mode):

- return 'Chmod(%s, 0%o)' % (get_paths_str(dest), mode)

-

-Chmod = ActionFactory(chmod_func, chmod_strfunc)

-

-def copy_func(dest, src):

- SCons.Node.FS.invalidate_node_memos(dest)

- if SCons.Util.is_List(src) and os.path.isdir(dest):

- for file in src:

- shutil.copy2(file, dest)

- return 0

- elif os.path.isfile(src):

- return shutil.copy2(src, dest)

- else:

- return shutil.copytree(src, dest, 1)

-

-Copy = ActionFactory(copy_func,

- lambda dest, src: 'Copy("%s", "%s")' % (dest, src),

- convert=str)

-

-def delete_func(dest, must_exist=0):

- SCons.Node.FS.invalidate_node_memos(dest)

- if not SCons.Util.is_List(dest):

- dest = [dest]

- for entry in dest:

- entry = str(entry)

- if not must_exist and not os.path.exists(entry):

- continue

- if not os.path.exists(entry) or os.path.isfile(entry):

- os.unlink(entry)

- continue

- else:

- shutil.rmtree(entry, 1)

- continue

-

-def delete_strfunc(dest, must_exist=0):

- return 'Delete(%s)' % get_paths_str(dest)

-

-Delete = ActionFactory(delete_func, delete_strfunc)

-

-def mkdir_func(dest):

- SCons.Node.FS.invalidate_node_memos(dest)

- if not SCons.Util.is_List(dest):

- dest = [dest]

- for entry in dest:

- try:

- os.makedirs(str(entry))

- except os.error, e:

- p = str(entry)

- if (e[0] == errno.EEXIST or (sys.platform=='win32' and e[0]==183)) \

- and os.path.isdir(str(entry)):

- pass # not an error if already exists

- else:

- raise

-

-Mkdir = ActionFactory(mkdir_func,

- lambda dir: 'Mkdir(%s)' % get_paths_str(dir))

-

-def move_func(dest, src):

- SCons.Node.FS.invalidate_node_memos(dest)

- SCons.Node.FS.invalidate_node_memos(src)

- os.rename(src, dest)

-

-Move = ActionFactory(move_func,

- lambda dest, src: 'Move("%s", "%s")' % (dest, src),

- convert=str)

-

-def touch_func(dest):

- SCons.Node.FS.invalidate_node_memos(dest)

- if not SCons.Util.is_List(dest):

- dest = [dest]

- for file in dest:

- file = str(file)

- mtime = int(time.time())

- if os.path.exists(file):

- atime = os.path.getatime(file)

- else:

- open(file, 'w')

- atime = mtime

- os.utime(file, (atime, mtime))

-

-Touch = ActionFactory(touch_func,

- lambda file: 'Touch(%s)' % get_paths_str(file))

-

-# Internal utility functions

-

-def _concat(prefix, list, suffix, env, f=lambda x: x, target=None, source=None):

- """

- Creates a new list from 'list' by first interpolating each element

- in the list using the 'env' dictionary and then calling f on the

- list, and finally calling _concat_ixes to concatenate 'prefix' and

- 'suffix' onto each element of the list.

- """

- if not list:

- return list

-

- l = f(SCons.PathList.PathList(list).subst_path(env, target, source))

- if not l is None:

- list = l

-

- return _concat_ixes(prefix, list, suffix, env)

-

-def _concat_ixes(prefix, list, suffix, env):

- """

- Creates a new list from 'list' by concatenating the 'prefix' and

- 'suffix' arguments onto each element of the list. A trailing space

- on 'prefix' or leading space on 'suffix' will cause them to be put

- into separate list elements rather than being concatenated.

- """

-

- result = []

-

- # ensure that prefix and suffix are strings

- prefix = str(env.subst(prefix, SCons.Subst.SUBST_RAW))

- suffix = str(env.subst(suffix, SCons.Subst.SUBST_RAW))

-

- for x in list:

- if isinstance(x, SCons.Node.FS.File):

- result.append(x)

- continue

- x = str(x)

- if x:

-

- if prefix:

- if prefix[-1] == ' ':

- result.append(prefix[:-1])

- elif x[:len(prefix)] != prefix:

- x = prefix + x

-

- result.append(x)

-

- if suffix:

- if suffix[0] == ' ':

- result.append(suffix[1:])

- elif x[-len(suffix):] != suffix:

- result[-1] = result[-1]+suffix

-

- return result

-

-def _stripixes(prefix, list, suffix, stripprefixes, stripsuffixes, env, c=None):

- """

- This is a wrapper around _concat()/_concat_ixes() that checks for the

- existence of prefixes or suffixes on list elements and strips them

- where it finds them. This is used by tools (like the GNU linker)

- that need to turn something like 'libfoo.a' into '-lfoo'.

- """

-

- if not list:

- return list

-

- if not callable(c):

- env_c = env['_concat']

- if env_c != _concat and callable(env_c):

- # There's a custom _concat() method in the construction

- # environment, and we've allowed people to set that in

- # the past (see test/custom-concat.py), so preserve the

- # backwards compatibility.

- c = env_c

- else:

- c = _concat_ixes

-

- stripprefixes = map(env.subst, SCons.Util.flatten(stripprefixes))

- stripsuffixes = map(env.subst, SCons.Util.flatten(stripsuffixes))

-

- stripped = []

- for l in SCons.PathList.PathList(list).subst_path(env, None, None):

- if isinstance(l, SCons.Node.FS.File):

- stripped.append(l)

- continue

-

- if not SCons.Util.is_String(l):

- l = str(l)

-

- for stripprefix in stripprefixes:

- lsp = len(stripprefix)

- if l[:lsp] == stripprefix:

- l = l[lsp:]

- # Do not strip more than one prefix

- break

-

- for stripsuffix in stripsuffixes:

- lss = len(stripsuffix)

- if l[-lss:] == stripsuffix:

- l = l[:-lss]

- # Do not strip more than one suffix

- break

-

- stripped.append(l)

-

- return c(prefix, stripped, suffix, env)

-

-def _defines(prefix, defs, suffix, env, c=_concat_ixes):

- """A wrapper around _concat_ixes that turns a list or string

- into a list of C preprocessor command-line definitions.

- """

- if SCons.Util.is_List(defs):

- l = []

- for d in defs:

- if SCons.Util.is_List(d) or type(d) is types.TupleType:

- l.append(str(d[0]) + '=' + str(d[1]))

- else:

- l.append(str(d))

- elif SCons.Util.is_Dict(defs):

- # The items in a dictionary are stored in random order, but

- # if the order of the command-line options changes from

- # invocation to invocation, then the signature of the command

- # line will change and we'll get random unnecessary rebuilds.

- # Consequently, we have to sort the keys to ensure a

- # consistent order...

- l = []

- keys = defs.keys()

- keys.sort()

- for k in keys:

- v = defs[k]

- if v is None:

- l.append(str(k))

- else:

- l.append(str(k) + '=' + str(v))

- else:

- l = [str(defs)]

- return c(prefix, env.subst_path(l), suffix, env)

-

-class NullCmdGenerator:

- """This is a callable class that can be used in place of other

- command generators if you don't want them to do anything.

-

- The __call__ method for this class simply returns the thing

- you instantiated it with.

-

- Example usage:

- env["DO_NOTHING"] = NullCmdGenerator

- env["LINKCOM"] = "${DO_NOTHING('$LINK $SOURCES $TARGET')}"

- """

-

- def __init__(self, cmd):

- self.cmd = cmd

-

- def __call__(self, target, source, env, for_signature=None):

- return self.cmd

-

-class Variable_Method_Caller:

- """A class for finding a construction variable on the stack and

- calling one of its methods.

-

- We use this to support "construction variables" in our string

- eval()s that actually stand in for methods--specifically, use

- of "RDirs" in call to _concat that should actually execute the

- "TARGET.RDirs" method. (We used to support this by creating a little

- "build dictionary" that mapped RDirs to the method, but this got in

- the way of Memoizing construction environments, because we had to

- create new environment objects to hold the variables.)

- """

- def __init__(self, variable, method):

- self.variable = variable

- self.method = method

- def __call__(self, *args, **kw):

- try: 1/0

- except ZeroDivisionError:

- # Don't start iterating with the current stack-frame to

- # prevent creating reference cycles (f_back is safe).

- frame = sys.exc_info()[2].tb_frame.f_back

- variable = self.variable

- while frame:

- if frame.f_locals.has_key(variable):

- v = frame.f_locals[variable]

- if v:

- method = getattr(v, self.method)

- return apply(method, args, kw)

- frame = frame.f_back

- return None

-

-ConstructionEnvironment = {

- 'BUILDERS' : {},

- 'SCANNERS' : [],

- 'CONFIGUREDIR' : '#/.sconf_temp',

- 'CONFIGURELOG' : '#/config.log',

- 'CPPSUFFIXES' : SCons.Tool.CSuffixes,

- 'DSUFFIXES' : SCons.Tool.DSuffixes,

- 'ENV' : {},

- 'IDLSUFFIXES' : SCons.Tool.IDLSuffixes,

- 'LATEXSUFFIXES' : SCons.Tool.LaTeXSuffixes,

- '_concat' : _concat,

- '_defines' : _defines,

- '_stripixes' : _stripixes,

- '_LIBFLAGS' : '${_concat(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, __env__)}',

- '_LIBDIRFLAGS' : '$( ${_concat(LIBDIRPREFIX, LIBPATH, LIBDIRSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)',

- '_CPPINCFLAGS' : '$( ${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)',

- '_CPPDEFFLAGS' : '${_defines(CPPDEFPREFIX, CPPDEFINES, CPPDEFSUFFIX, __env__)}',

- 'TEMPFILE' : NullCmdGenerator,

- 'Dir' : Variable_Method_Caller('TARGET', 'Dir'),

- 'Dirs' : Variable_Method_Caller('TARGET', 'Dirs'),

- 'File' : Variable_Method_Caller('TARGET', 'File'),

- 'RDirs' : Variable_Method_Caller('TARGET', 'RDirs'),

-}

-

-# Local Variables:

-# tab-width:4

-# indent-tabs-mode:nil

-# End:

-# vim: set expandtab tabstop=4 shiftwidth=4:

-"""SCons.Environment

-

-Base class for construction Environments. These are

-the primary objects used to communicate dependency and

-construction information to the build engine.

-

-Keyword arguments supplied when the construction Environment

-is created are construction variables used to initialize the

-Environment

-"""

-

-#

-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation

-#

-# Permission is hereby granted, free of charge, to any person obtaining

-# a copy of this software and associated documentation files (the

-# "Software"), to deal in the Software without restriction, including

-# without limitation the rights to use, copy, modify, merge, publish,

-# distribute, sublicense, and/or sell copies of the Software, and to

-# permit persons to whom the Software is furnished to do so, subject to

-# the following conditions:

-#

-# The above copyright notice and this permission notice shall be included

-# in all copies or substantial portions of the Software.

-#

-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY

-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-#

-

-__revision__ = "src/engine/SCons/Environment.py 4043 2009/02/23 09:06:45 scons"

-

-

-import copy

-import os

-import sys

-import re

-import shlex

-import string

-from UserDict import UserDict

-

-import SCons.Action

-import SCons.Builder

-from SCons.Debug import logInstanceCreation

-import SCons.Defaults

-import SCons.Errors

-import SCons.Memoize

-import SCons.Node

-import SCons.Node.Alias

-import SCons.Node.FS

-import SCons.Node.Python

-import SCons.Platform

-import SCons.SConsign

-import SCons.Subst

-import SCons.Tool

-import SCons.Util

-import SCons.Warnings

-

-class _Null:

- pass

-

-_null = _Null

-

-_warn_copy_deprecated = True

-_warn_source_signatures_deprecated = True

-_warn_target_signatures_deprecated = True

-

-CleanTargets = {}

-CalculatorArgs = {}

-

-semi_deepcopy = SCons.Util.semi_deepcopy

-

-# Pull UserError into the global name space for the benefit of

-# Environment().SourceSignatures(), which has some import statements

-# which seem to mess up its ability to reference SCons directly.

-UserError = SCons.Errors.UserError

-

-def alias_builder(env, target, source):

- pass

-

-AliasBuilder = SCons.Builder.Builder(action = alias_builder,

- target_factory = SCons.Node.Alias.default_ans.Alias,

- source_factory = SCons.Node.FS.Entry,

- multi = 1,

- is_explicit = None,

- name='AliasBuilder')

-

-def apply_tools(env, tools, toolpath):

- # Store the toolpath in the Environment.

- if toolpath is not None:

- env['toolpath'] = toolpath

-

- if not tools:

- return

- # Filter out null tools from the list.

- for tool in filter(None, tools):

- if SCons.Util.is_List(tool) or type(tool)==type(()):

- toolname = tool[0]

- toolargs = tool[1] # should be a dict of kw args

- tool = apply(env.Tool, [toolname], toolargs)

- else:

- env.Tool(tool)

-

-# These names are (or will be) controlled by SCons; users should never

-# set or override them. This warning can optionally be turned off,

-# but scons will still ignore the illegal variable names even if it's off.

-reserved_construction_var_names = [

- 'CHANGED_SOURCES',

- 'CHANGED_TARGETS',

- 'SOURCE',

- 'SOURCES',

- 'TARGET',

- 'TARGETS',

- 'UNCHANGED_SOURCES',

- 'UNCHANGED_TARGETS',

-]

-

-future_reserved_construction_var_names = []

-

-def copy_non_reserved_keywords(dict):

- result = semi_deepcopy(dict)

- for k in result.keys():

- if k in reserved_construction_var_names:

- msg = "Ignoring attempt to set reserved variable `$%s'"

- SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % k)

- del result[k]

- return result

-

-def _set_reserved(env, key, value):

- msg = "Ignoring attempt to set reserved variable `$%s'"

- SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % key)

-

-def _set_future_reserved(env, key, value):

- env._dict[key] = value

- msg = "`$%s' will be reserved in a future release and setting it will become ignored"

- SCons.Warnings.warn(SCons.Warnings.FutureReservedVariableWarning, msg % key)

-

-def _set_BUILDERS(env, key, value):

- try:

- bd = env._dict[key]

- for k in bd.keys():

- del bd[k]

- except KeyError:

- bd = BuilderDict(kwbd, env)

- env._dict[key] = bd

- bd.update(value)

-

-def _del_SCANNERS(env, key):

- del env._dict[key]

- env.scanner_map_delete()

-

-def _set_SCANNERS(env, key, value):

- env._dict[key] = value

- env.scanner_map_delete()

-

-def _delete_duplicates(l, keep_last):

- """Delete duplicates from a sequence, keeping the first or last."""

- seen={}

- result=[]

- if keep_last: # reverse in & out, then keep first

- l.reverse()

- for i in l:

- try:

- if not seen.has_key(i):

- result.append(i)

- seen[i]=1

- except TypeError:

- # probably unhashable. Just keep it.

- result.append(i)

- if keep_last:

- result.reverse()

- return result

-

-

-

-# The following is partly based on code in a comment added by Peter

-# Shannon at the following page (there called the "transplant" class):

-#

-# ASPN : Python Cookbook : Dynamically added methods to a class

-# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81732

-#

-# We had independently been using the idiom as BuilderWrapper, but

-# factoring out the common parts into this base class, and making

-# BuilderWrapper a subclass that overrides __call__() to enforce specific

-# Builder calling conventions, simplified some of our higher-layer code.

-

-class MethodWrapper:

- """

- A generic Wrapper class that associates a method (which can

- actually be any callable) with an object. As part of creating this

- MethodWrapper object an attribute with the specified (by default,

- the name of the supplied method) is added to the underlying object.

- When that new "method" is called, our __call__() method adds the

- object as the first argument, simulating the Python behavior of

- supplying "self" on method calls.

-

- We hang on to the name by which the method was added to the underlying

- base class so that we can provide a method to "clone" ourselves onto

- a new underlying object being copied (without which we wouldn't need

- to save that info).

- """

- def __init__(self, object, method, name=None):

- if name is None:

- name = method.__name__

- self.object = object

- self.method = method

- self.name = name

- setattr(self.object, name, self)

-

- def __call__(self, *args, **kwargs):

- nargs = (self.object,) + args

- return apply(self.method, nargs, kwargs)

-

- def clone(self, new_object):

- """

- Returns an object that re-binds the underlying "method" to

- the specified new object.

- """

- return self.__class__(new_object, self.method, self.name)

-

-class BuilderWrapper(MethodWrapper):

- """

- A MethodWrapper subclass that that associates an environment with

- a Builder.

-

- This mainly exists to wrap the __call__() function so that all calls

- to Builders can have their argument lists massaged in the same way

- (treat a lone argument as the source, treat two arguments as target

- then source, make sure both target and source are lists) without

- having to have cut-and-paste code to do it.

-

- As a bit of obsessive backwards compatibility, we also intercept

- attempts to get or set the "env" or "builder" attributes, which were

- the names we used before we put the common functionality into the

- MethodWrapper base class. We'll keep this around for a while in case

- people shipped Tool modules that reached into the wrapper (like the

- Tool/qt.py module does, or did). There shouldn't be a lot attribute

- fetching or setting on these, so a little extra work shouldn't hurt.

- """

- def __call__(self, target=None, source=_null, *args, **kw):

- if source is _null:

- source = target

- target = None

- if not target is None and not SCons.Util.is_List(target):

- target = [target]

- if not source is None and not SCons.Util.is_List(source):

- source = [source]

- return apply(MethodWrapper.__call__, (self, target, source) + args, kw)

-

- def __repr__(self):

- return '<BuilderWrapper %s>' % repr(self.name)

-

- def __str__(self):

- return self.__repr__()

-

- def __getattr__(self, name):

- if name == 'env':

- return self.object

- elif name == 'builder':

- return self.method

- else:

- raise AttributeError, name

-

- def __setattr__(self, name, value):

- if name == 'env':

- self.object = value

- elif name == 'builder':

- self.method = value

- else:

- self.__dict__[name] = value

-

- # This allows a Builder to be executed directly

- # through the Environment to which it's attached.

- # In practice, we shouldn't need this, because

- # builders actually get executed through a Node.

- # But we do have a unit test for this, and can't

- # yet rule out that it would be useful in the

- # future, so leave it for now.

- #def execute(self, **kw):

- # kw['env'] = self.env

- # apply(self.builder.execute, (), kw)

-

-class BuilderDict(UserDict):

- """This is a dictionary-like class used by an Environment to hold

- the Builders. We need to do this because every time someone changes

- the Builders in the Environment's BUILDERS dictionary, we must

- update the Environment's attributes."""

- def __init__(self, dict, env):

- # Set self.env before calling the superclass initialization,

- # because it will end up calling our other methods, which will

- # need to point the values in this dictionary to self.env.

- self.env = env

- UserDict.__init__(self, dict)

-

- def __semi_deepcopy__(self):

- return self.__class__(self.data, self.env)

-

- def __setitem__(self, item, val):

- try:

- method = getattr(self.env, item).method

- except AttributeError:

- pass

- else:

- self.env.RemoveMethod(method)

- UserDict.__setitem__(self, item, val)

- BuilderWrapper(self.env, val, item)

-

- def __delitem__(self, item):

- UserDict.__delitem__(self, item)

- delattr(self.env, item)

-

- def update(self, dict):

- for i, v in dict.items():

- self.__setitem__(i, v)

-

-

-

-_is_valid_var = re.compile(r'[_a-zA-Z]\w*$')

-

-def is_valid_construction_var(varstr):

- """Return if the specified string is a legitimate construction

- variable.

- """

- return _is_valid_var.match(varstr)

-

-

-

-class SubstitutionEnvironment:

- """Base class for different flavors of construction environments.

-

- This class contains a minimal set of methods that handle contruction

- variable expansion and conversion of strings to Nodes, which may or

- may not be actually useful as a stand-alone class. Which methods

- ended up in this class is pretty arbitrary right now. They're

- basically the ones which we've empirically determined are common to

- the different construction environment subclasses, and most of the

- others that use or touch the underlying dictionary of construction

- variables.

-

- Eventually, this class should contain all the methods that we

- determine are necessary for a "minimal" interface to the build engine.

- A full "native Python" SCons environment has gotten pretty heavyweight

- with all of the methods and Tools and construction variables we've

- jammed in there, so it would be nice to have a lighter weight

- alternative for interfaces that don't need all of the bells and

- whistles. (At some point, we'll also probably rename this class

- "Base," since that more reflects what we want this class to become,

- but because we've released comments that tell people to subclass

- Environment.Base to create their own flavors of construction

- environment, we'll save that for a future refactoring when this

- class actually becomes useful.)

- """

-

- if SCons.Memoize.use_memoizer:

- __metaclass__ = SCons.Memoize.Memoized_Metaclass

-

- def __init__(self, **kw):

- """Initialization of an underlying SubstitutionEnvironment class.

- """

- if __debug__: logInstanceCreation(self, 'Environment.SubstitutionEnvironment')

- self.fs = SCons.Node.FS.get_default_fs()

- self.ans = SCons.Node.Alias.default_ans

- self.lookup_list = SCons.Node.arg2nodes_lookups

- self._dict = kw.copy()

- self._init_special()

- self.added_methods = []

- #self._memo = {}

-

- def _init_special(self):

- """Initial the dispatch tables for special handling of

- special construction variables."""

- self._special_del = {}

- self._special_del['SCANNERS'] = _del_SCANNERS

-

- self._special_set = {}

- for key in reserved_construction_var_names:

- self._special_set[key] = _set_reserved

- for key in future_reserved_construction_var_names:

- self._special_set[key] = _set_future_reserved

- self._special_set['BUILDERS'] = _set_BUILDERS

- self._special_set['SCANNERS'] = _set_SCANNERS

-

- # Freeze the keys of self._special_set in a list for use by

- # methods that need to check. (Empirically, list scanning has

- # gotten better than dict.has_key() in Python 2.5.)

- self._special_set_keys = self._special_set.keys()

-

- def __cmp__(self, other):

- return cmp(self._dict, other._dict)

-

- def __delitem__(self, key):

- special = self._special_del.get(key)

- if special:

- special(self, key)

- else:

- del self._dict[key]

-

- def __getitem__(self, key):

- return self._dict[key]

-

- def __setitem__(self, key, value):

- # This is heavily used. This implementation is the best we have

- # according to the timings in bench/env.__setitem__.py.

- #

- # The "key in self._special_set_keys" test here seems to perform

- # pretty well for the number of keys we have. A hard-coded

- # list works a little better in Python 2.5, but that has the

- # disadvantage of maybe getting out of sync if we ever add more

- # variable names. Using self._special_set.has_key() works a

- # little better in Python 2.4, but is worse then this test.

- # So right now it seems like a good trade-off, but feel free to

- # revisit this with bench/env.__setitem__.py as needed (and

- # as newer versions of Python come out).

- if key in self._special_set_keys:

- self._special_set[key](self, key, value)

- else:

- # If we already have the entry, then it's obviously a valid

- # key and we don't need to check. If we do check, using a

- # global, pre-compiled regular expression directly is more

- # efficient than calling another function or a method.

- if not self._dict.has_key(key) \

- and not _is_valid_var.match(key):

- raise SCons.Errors.UserError, "Illegal construction variable `%s'" % key

- self._dict[key] = value

-

- def get(self, key, default=None):

- """Emulates the get() method of dictionaries."""

- return self._dict.get(key, default)

-

- def has_key(self, key):

- return self._dict.has_key(key)

-

- def __contains__(self, key):

- return self._dict.__contains__(key)

-

- def items(self):

- return self._dict.items()

-

- def arg2nodes(self, args, node_factory=_null, lookup_list=_null, **kw):

- if node_factory is _null:

- node_factory = self.fs.File

- if lookup_list is _null:

- lookup_list = self.lookup_list

-

- if not args:

- return []

-

- args = SCons.Util.flatten(args)

-

- nodes = []

- for v in args:

- if SCons.Util.is_String(v):

- n = None

- for l in lookup_list:

- n = l(v)

- if not n is None:

- break

- if not n is None:

- if SCons.Util.is_String(n):

- # n = self.subst(n, raw=1, **kw)

- kw['raw'] = 1

- n = apply(self.subst, (n,), kw)

- if node_factory:

- n = node_factory(n)

- if SCons.Util.is_List(n):

- nodes.extend(n)

- else:

- nodes.append(n)

- elif node_factory:

- # v = node_factory(self.subst(v, raw=1, **kw))

- kw['raw'] = 1

- v = node_factory(apply(self.subst, (v,), kw))

- if SCons.Util.is_List(v):

- nodes.extend(v)

- else:

- nodes.append(v)

- else:

- nodes.append(v)

-

- return nodes

-

- def gvars(self):

- return self._dict

-

- def lvars(self):

- return {}

-

- def subst(self, string, raw=0, target=None, source=None, conv=None, executor=None):

- """Recursively interpolates construction variables from the

- Environment into the specified string, returning the expanded

- result. Construction variables are specified by a $ prefix

- in the string and begin with an initial underscore or

- alphabetic character followed by any number of underscores

- or alphanumeric characters. The construction variable names

- may be surrounded by curly braces to separate the name from

- trailing characters.

- """

- gvars = self.gvars()

- lvars = self.lvars()

- lvars['__env__'] = self

- if executor:

- lvars.update(executor.get_lvars())

- return SCons.Subst.scons_subst(string, self, raw, target, source, gvars, lvars, conv)

-

- def subst_kw(self, kw, raw=0, target=None, source=None):

- nkw = {}

- for k, v in kw.items():

- k = self.subst(k, raw, target, source)

- if SCons.Util.is_String(v):

- v = self.subst(v, raw, target, source)

- nkw[k] = v

- return nkw

-

- def subst_list(self, string, raw=0, target=None, source=None, conv=None, executor=None):

- """Calls through to SCons.Subst.scons_subst_list(). See

- the documentation for that function."""

- gvars = self.gvars()

- lvars = self.lvars()

- lvars['__env__'] = self

- if executor:

- lvars.update(executor.get_lvars())

- return SCons.Subst.scons_subst_list(string, self, raw, target, source, gvars, lvars, conv)

-

- def subst_path(self, path, target=None, source=None):

- """Substitute a path list, turning EntryProxies into Nodes

- and leaving Nodes (and other objects) as-is."""

-

- if not SCons.Util.is_List(path):

- path = [path]

-

- def s(obj):

- """This is the "string conversion" routine that we have our

- substitutions use to return Nodes, not strings. This relies

- on the fact that an EntryProxy object has a get() method that

- returns the underlying Node that it wraps, which is a bit of

- architectural dependence that we might need to break or modify

- in the future in response to additional requirements."""

- try:

- get = obj.get

- except AttributeError:

- obj = SCons.Util.to_String_for_subst(obj)

- else:

- obj = get()

- return obj

-

- r = []

- for p in path:

- if SCons.Util.is_String(p):

- p = self.subst(p, target=target, source=source, conv=s)

- if SCons.Util.is_List(p):

- if len(p) == 1:

- p = p[0]

- else:

- # We have an object plus a string, or multiple

- # objects that we need to smush together. No choice

- # but to make them into a string.

- p = string.join(map(SCons.Util.to_String_for_subst, p), '')

- else:

- p = s(p)

- r.append(p)

- return r

-

- subst_target_source = subst

-

- def backtick(self, command):

- import subprocess

- # common arguments

- kw = { 'stdin' : 'devnull',

- 'stdout' : subprocess.PIPE,

- 'stderr' : subprocess.PIPE,

- 'universal_newlines' : True,

- }

- # if the command is a list, assume it's been quoted

- # othewise force a shell

- if not SCons.Util.is_List(command): kw['shell'] = True

- # run constructed command

- #TODO(1.5) p = SCons.Action._subproc(self, command, **kw)

- p = apply(SCons.Action._subproc, (self, command), kw)

- out,err = p.communicate()

- status = p.wait()

- if err:

- sys.stderr.write(err)

- if status:

- raise OSError("'%s' exited %d" % (command, status))

- return out

-

- def AddMethod(self, function, name=None):

- """

- Adds the specified function as a method of this construction

- environment with the specified name. If the name is omitted,

- the default name is the name of the function itself.

- """

- method = MethodWrapper(self, function, name)

- self.added_methods.append(method)

-

- def RemoveMethod(self, function):

- """

- Removes the specified function's MethodWrapper from the

- added_methods list, so we don't re-bind it when making a clone.

- """

- is_not_func = lambda dm, f=function: not dm.method is f

- self.added_methods = filter(is_not_func, self.added_methods)

-

- def Override(self, overrides):

- """

- Produce a modified environment whose variables are overriden by

- the overrides dictionaries. "overrides" is a dictionary that

- will override the variables of this environment.

-

- This function is much more efficient than Clone() or creating

- a new Environment because it doesn't copy the construction

- environment dictionary, it just wraps the underlying construction

- environment, and doesn't even create a wrapper object if there

- are no overrides.

- """

- if not overrides: return self

- o = copy_non_reserved_keywords(overrides)

- if not o: return self

- overrides = {}

- merges = None

- for key, value in o.items():

- if key == 'parse_flags':

- merges = value

- else:

- overrides[key] = SCons.Subst.scons_subst_once(value, self, key)

- env = OverrideEnvironment(self, overrides)

- if merges: env.MergeFlags(merges)

- return env

-

- def ParseFlags(self, *flags):

- """

- Parse the set of flags and return a dict with the flags placed

- in the appropriate entry. The flags are treated as a typical

- set of command-line flags for a GNU-like toolchain and used to

- populate the entries in the dict immediately below. If one of

- the flag strings begins with a bang (exclamation mark), it is

- assumed to be a command and the rest of the string is executed;

- the result of that evaluation is then added to the dict.

- """

- dict = {

- 'ASFLAGS' : SCons.Util.CLVar(''),

- 'CFLAGS' : SCons.Util.CLVar(''),

- 'CCFLAGS' : SCons.Util.CLVar(''),

- 'CPPDEFINES' : [],

- 'CPPFLAGS' : SCons.Util.CLVar(''),

- 'CPPPATH' : [],

- 'FRAMEWORKPATH' : SCons.Util.CLVar(''),

- 'FRAMEWORKS' : SCons.Util.CLVar(''),

- 'LIBPATH' : [],

- 'LIBS' : [],

- 'LINKFLAGS' : SCons.Util.CLVar(''),

- 'RPATH' : [],

- }

-

- # The use of the "me" parameter to provide our own name for

- # recursion is an egregious hack to support Python 2.1 and before.

- def do_parse(arg, me, self = self, dict = dict):

- # if arg is a sequence, recurse with each element

- if not arg:

- return

-

- if not SCons.Util.is_String(arg):

- for t in arg: me(t, me)

- return

-

- # if arg is a command, execute it

- if arg[0] == '!':

- arg = self.backtick(arg[1:])

-

- # utility function to deal with -D option

- def append_define(name, dict = dict):

- t = string.split(name, '=')

- if len(t) == 1:

- dict['CPPDEFINES'].append(name)

- else:

- dict['CPPDEFINES'].append([t[0], string.join(t[1:], '=')])

-

- # Loop through the flags and add them to the appropriate option.

- # This tries to strike a balance between checking for all possible

- # flags and keeping the logic to a finite size, so it doesn't

- # check for some that don't occur often. It particular, if the

- # flag is not known to occur in a config script and there's a way

- # of passing the flag to the right place (by wrapping it in a -W

- # flag, for example) we don't check for it. Note that most

- # preprocessor options are not handled, since unhandled options

- # are placed in CCFLAGS, so unless the preprocessor is invoked

- # separately, these flags will still get to the preprocessor.

- # Other options not currently handled:

- # -iqoutedir (preprocessor search path)

- # -u symbol (linker undefined symbol)

- # -s (linker strip files)

- # -static* (linker static binding)

- # -shared* (linker dynamic binding)

- # -symbolic (linker global binding)

- # -R dir (deprecated linker rpath)

- # IBM compilers may also accept -qframeworkdir=foo

-

- params = shlex.split(arg)

- append_next_arg_to = None # for multi-word args

- for arg in params:

- if append_next_arg_to:

- if append_next_arg_to == 'CPPDEFINES':

- append_define(arg)

- elif append_next_arg_to == '-include':

- t = ('-include', self.fs.File(arg))

- dict['CCFLAGS'].append(t)

- elif append_next_arg_to == '-isysroot':

- t = ('-isysroot', arg)

- dict['CCFLAGS'].append(t)

- dict['LINKFLAGS'].append(t)

- elif append_next_arg_to == '-arch':

- t = ('-arch', arg)

- dict['CCFLAGS'].append(t)

- dict['LINKFLAGS'].append(t)

- else:

- dict[append_next_arg_to].append(arg)

- append_next_arg_to = None

- elif not arg[0] in ['-', '+']:

- dict['LIBS'].append(self.fs.File(arg))

- elif arg[:2] == '-L':

- if arg[2:]:

- dict['LIBPATH'].append(arg[2:])

- else:

- append_next_arg_to = 'LIBPATH'

- elif arg[:2] == '-l':

- if arg[2:]:

- dict['LIBS'].append(arg[2:])

- else:

- append_next_arg_to = 'LIBS'

- elif arg[:2] == '-I':

- if arg[2:]:

- dict['CPPPATH'].append(arg[2:])

- else:

- append_next_arg_to = 'CPPPATH'

- elif arg[:4] == '-Wa,':

- dict['ASFLAGS'].append(arg[4:])

- dict['CCFLAGS'].append(arg)

- elif arg[:4] == '-Wl,':

- if arg[:11] == '-Wl,-rpath=':

- dict['RPATH'].append(arg[11:])

- elif arg[:7] == '-Wl,-R,':

- dict['RPATH'].append(arg[7:])

- elif arg[:6] == '-Wl,-R':

- dict['RPATH'].append(arg[6:])

- else:

- dict['LINKFLAGS'].append(arg)

- elif arg[:4] == '-Wp,':

- dict['CPPFLAGS'].append(arg)

- elif arg[:2] == '-D':

- if arg[2:]:

- append_define(arg[2:])

- else:

- append_next_arg_to = 'CPPDEFINES'

- elif arg == '-framework':

- append_next_arg_to = 'FRAMEWORKS'

- elif arg[:14] == '-frameworkdir=':

- dict['FRAMEWORKPATH'].append(arg[14:])

- elif arg[:2] == '-F':

- if arg[2:]:

- dict['FRAMEWORKPATH'].append(arg[2:])

- else:

- append_next_arg_to = 'FRAMEWORKPATH'

- elif arg == '-mno-cygwin':

- dict['CCFLAGS'].append(arg)

- dict['LINKFLAGS'].append(arg)

- elif arg == '-mwindows':

- dict['LINKFLAGS'].append(arg)

- elif arg == '-pthread':

- dict['CCFLAGS'].append(arg)

- dict['LINKFLAGS'].append(arg)

- elif arg[:5] == '-std=':

- dict['CFLAGS'].append(arg) # C only

- elif arg[0] == '+':

- dict['CCFLAGS'].append(arg)

- dict['LINKFLAGS'].append(arg)

- elif arg in ['-include', '-isysroot', '-arch']:

- append_next_arg_to = arg

- else:

- dict['CCFLAGS'].append(arg)

-

- for arg in flags:

- do_parse(arg, do_parse)

- return dict

-

- def MergeFlags(self, args, unique=1, dict=None):

- """

- Merge the dict in args into the construction variables of this

- env, or the passed-in dict. If args is not a dict, it is

- converted into a dict using ParseFlags. If unique is not set,

- the flags are appended rather than merged.

- """

-

- if dict is None:

- dict = self

- if not SCons.Util.is_Dict(args):

- args = self.ParseFlags(args)

- if not unique:

- apply(self.Append, (), args)

- return self

- for key, value in args.items():

- if not value:

- continue

- try:

- orig = self[key]

- except KeyError:

- orig = value

- else:

- if not orig:

- orig = value

- elif value:

- # Add orig and value. The logic here was lifted from

- # part of env.Append() (see there for a lot of comments

- # about the order in which things are tried) and is

- # used mainly to handle coercion of strings to CLVar to

- # "do the right thing" given (e.g.) an original CCFLAGS

- # string variable like '-pipe -Wall'.

- try:

- orig = orig + value

- except (KeyError, TypeError):

- try:

- add_to_orig = orig.append

- except AttributeError:

- value.insert(0, orig)

- orig = value

- else:

- add_to_orig(value)

- t = []

- if key[-4:] == 'PATH':

- ### keep left-most occurence

- for v in orig:

- if v not in t:

- t.append(v)

- else:

- ### keep right-most occurence

- orig.reverse()

- for v in orig:

- if v not in t:

- t.insert(0, v)

- self[key] = t

- return self

-

-# def MergeShellPaths(self, args, prepend=1):

-# """

-# Merge the dict in args into the shell environment in env['ENV'].

-# Shell path elements are appended or prepended according to prepend.

-

-# Uses Pre/AppendENVPath, so it always appends or prepends uniquely.

-

-# Example: env.MergeShellPaths({'LIBPATH': '/usr/local/lib'})

-# prepends /usr/local/lib to env['ENV']['LIBPATH'].

-# """

-

-# for pathname, pathval in args.items():

-# if not pathval:

-# continue

-# if prepend:

-# apply(self.PrependENVPath, (pathname, pathval))

-# else:

-# apply(self.AppendENVPath, (pathname, pathval))

-

-

-# Used by the FindSourceFiles() method, below.

-# Stuck here for support of pre-2.2 Python versions.

-def build_source(ss, result):

- for s in ss:

- if isinstance(s, SCons.Node.FS.Dir):

- build_source(s.all_children(), result)

- elif s.has_builder():

- build_source(s.sources, result)

- elif isinstance(s.disambiguate(), SCons.Node.FS.File):

- result.append(s)

-

-def default_decide_source(dependency, target, prev_ni):

- f = SCons.Defaults.DefaultEnvironment().decide_source

- return f(dependency, target, prev_ni)

-

-def default_decide_target(dependency, target, prev_ni):

- f = SCons.Defaults.DefaultEnvironment().decide_target

- return f(dependency, target, prev_ni)

-

-def default_copy_from_cache(src, dst):

- f = SCons.Defaults.DefaultEnvironment().copy_from_cache

- return f(src, dst)

-

-class Base(SubstitutionEnvironment):

- """Base class for "real" construction Environments. These are the

- primary objects used to communicate dependency and construction

- information to the build engine.

-

- Keyword arguments supplied when the construction Environment

- is created are construction variables used to initialize the

- Environment.

- """

-

- if SCons.Memoize.use_memoizer:

- __metaclass__ = SCons.Memoize.Memoized_Metaclass

-

- memoizer_counters = []

-

- #######################################################################

- # This is THE class for interacting with the SCons build engine,

- # and it contains a lot of stuff, so we're going to try to keep this

- # a little organized by grouping the methods.

- #######################################################################

-

- #######################################################################

- # Methods that make an Environment act like a dictionary. These have

- # the expected standard names for Python mapping objects. Note that

- # we don't actually make an Environment a subclass of UserDict for

- # performance reasons. Note also that we only supply methods for

- # dictionary functionality that we actually need and use.

- #######################################################################

-

- def __init__(self,

- platform=None,

- tools=None,

- toolpath=None,

- variables=None,

- parse_flags = None,

- **kw):

- """

- Initialization of a basic SCons construction environment,

- including setting up special construction variables like BUILDER,

- PLATFORM, etc., and searching for and applying available Tools.

-

- Note that we do *not* call the underlying base class

- (SubsitutionEnvironment) initialization, because we need to

- initialize things in a very specific order that doesn't work

- with the much simpler base class initialization.

- """

- if __debug__: logInstanceCreation(self, 'Environment.Base')

- self._memo = {}

- self.fs = SCons.Node.FS.get_default_fs()

- self.ans = SCons.Node.Alias.default_ans

- self.lookup_list = SCons.Node.arg2nodes_lookups

- self._dict = semi_deepcopy(SCons.Defaults.ConstructionEnvironment)

- self._init_special()

- self.added_methods = []

-

- # We don't use AddMethod, or define these as methods in this

- # class, because we *don't* want these functions to be bound

- # methods. They need to operate independently so that the

- # settings will work properly regardless of whether a given

- # target ends up being built with a Base environment or an

- # OverrideEnvironment or what have you.

- self.decide_target = default_decide_target

- self.decide_source = default_decide_source

-

- self.copy_from_cache = default_copy_from_cache

-

- self._dict['BUILDERS'] = BuilderDict(self._dict['BUILDERS'], self)

-

- if platform is None:

- platform = self._dict.get('PLATFORM', None)

- if platform is None:

- platform = SCons.Platform.Platform()

- if SCons.Util.is_String(platform):

- platform = SCons.Platform.Platform(platform)

- self._dict['PLATFORM'] = str(platform)

- platform(self)

-

- # Apply the passed-in and customizable variables to the

- # environment before calling the tools, because they may use

- # some of them during initialization.

- if kw.has_key('options'):

- # Backwards compatibility: they may stll be using the

- # old "options" keyword.

- variables = kw['options']

- del kw['options']

- apply(self.Replace, (), kw)

- keys = kw.keys()

- if variables:

- keys = keys + variables.keys()

- variables.Update(self)

-

- save = {}

- for k in keys:

- try:

- save[k] = self._dict[k]

- except KeyError:

- # No value may have been set if they tried to pass in a

- # reserved variable name like TARGETS.

- pass

-

- SCons.Tool.Initializers(self)

-

- if tools is None:

- tools = self._dict.get('TOOLS', None)

- if tools is None:

- tools = ['default']

- apply_tools(self, tools, toolpath)

-

- # Now restore the passed-in and customized variables

- # to the environment, since the values the user set explicitly

- # should override any values set by the tools.

- for key, val in save.items():

- self._dict[key] = val

-

- # Finally, apply any flags to be merged in

- if parse_flags: self.MergeFlags(parse_flags)

-

- #######################################################################

- # Utility methods that are primarily for internal use by SCons.

- # These begin with lower-case letters.

- #######################################################################

-

- def get_builder(self, name):

- """Fetch the builder with the specified name from the environment.

- """

- try:

- return self._dict['BUILDERS'][name]

- except KeyError:

- return None

-

- def get_CacheDir(self):

- try:

- path = self._CacheDir_path

- except AttributeError:

- path = SCons.Defaults.DefaultEnvironment()._CacheDir_path

- try:

- if path == self._last_CacheDir_path:

- return self._last_CacheDir

- except AttributeError:

- pass

- cd = SCons.CacheDir.CacheDir(path)

- self._last_CacheDir_path = path

- self._last_CacheDir = cd

- return cd

-

- def get_factory(self, factory, default='File'):

- """Return a factory function for creating Nodes for this

- construction environment.

- """

- name = default

- try:

- is_node = issubclass(factory, SCons.Node.Node)

- except TypeError:

- # The specified factory isn't a Node itself--it's

- # most likely None, or possibly a callable.

- pass

- else:

- if is_node:

- # The specified factory is a Node (sub)class. Try to

- # return the FS method that corresponds to the Node's

- # name--that is, we return self.fs.Dir if they want a Dir,

- # self.fs.File for a File, etc.

- try: name = factory.__name__

- except AttributeError: pass

- else: factory = None

- if not factory:

- # They passed us None, or we picked up a name from a specified

- # class, so return the FS method. (Note that we *don't*

- # use our own self.{Dir,File} methods because that would

- # cause env.subst() to be called twice on the file name,

- # interfering with files that have $$ in them.)

- factory = getattr(self.fs, name)

- return factory

-

- memoizer_counters.append(SCons.Memoize.CountValue('_gsm'))

-

- def _gsm(self):

- try:

- return self._memo['_gsm']

- except KeyError:

- pass

-

- result = {}

-

- try:

- scanners = self._dict['SCANNERS']

- except KeyError:

- pass

- else:

- # Reverse the scanner list so that, if multiple scanners

- # claim they can scan the same suffix, earlier scanners

- # in the list will overwrite later scanners, so that

- # the result looks like a "first match" to the user.

- if not SCons.Util.is_List(scanners):

- scanners = [scanners]

- else:

- scanners = scanners[:] # copy so reverse() doesn't mod original

- scanners.reverse()

- for scanner in scanners:

- for k in scanner.get_skeys(self):

- if k and self['PLATFORM'] == 'win32':

- k = string.lower(k)

- result[k] = scanner

-

- self._memo['_gsm'] = result

-

- return result

-

- def get_scanner(self, skey):

- """Find the appropriate scanner given a key (usually a file suffix).

- """

- if skey and self['PLATFORM'] == 'win32':

- skey = string.lower(skey)

- return self._gsm().get(skey)

-

- def scanner_map_delete(self, kw=None):

- """Delete the cached scanner map (if we need to).

- """

- try:

- del self._memo['_gsm']

- except KeyError:

- pass

-

- def _update(self, dict):

- """Update an environment's values directly, bypassing the normal

- checks that occur when users try to set items.

- """

- self._dict.update(dict)

-

- def get_src_sig_type(self):

- try:

- return self.src_sig_type

- except AttributeError:

- t = SCons.Defaults.DefaultEnvironment().src_sig_type

- self.src_sig_type = t

- return t

-

- def get_tgt_sig_type(self):

- try:

- return self.tgt_sig_type

- except AttributeError:

- t = SCons.Defaults.DefaultEnvironment().tgt_sig_type

- self.tgt_sig_type = t

- return t

-

- #######################################################################

- # Public methods for manipulating an Environment. These begin with

- # upper-case letters. The essential characteristic of methods in

- # this section is that they do *not* have corresponding same-named

- # global functions. For example, a stand-alone Append() function

- # makes no sense, because Append() is all about appending values to

- # an Environment's construction variables.

- #######################################################################

-

- def Append(self, **kw):

- """Append values to existing construction variables

- in an Environment.

- """

- kw = copy_non_reserved_keywords(kw)

- for key, val in kw.items():

- # It would be easier on the eyes to write this using

- # "continue" statements whenever we finish processing an item,

- # but Python 1.5.2 apparently doesn't let you use "continue"

- # within try:-except: blocks, so we have to nest our code.

- try:

- orig = self._dict[key]

- except KeyError:

- # No existing variable in the environment, so just set

- # it to the new value.

- self._dict[key] = val

- else:

- try:

- # Check if the original looks like a dictionary.

- # If it is, we can't just try adding the value because

- # dictionaries don't have __add__() methods, and

- # things like UserList will incorrectly coerce the

- # original dict to a list (which we don't want).

- update_dict = orig.update

- except AttributeError:

- try:

- # Most straightforward: just try to add them

- # together. This will work in most cases, when the

- # original and new values are of compatible types.

- self._dict[key] = orig + val

- except (KeyError, TypeError):

- try:

- # Check if the original is a list.

- add_to_orig = orig.append

- except AttributeError:

- # The original isn't a list, but the new

- # value is (by process of elimination),

- # so insert the original in the new value

- # (if there's one to insert) and replace

- # the variable with it.

- if orig:

- val.insert(0, orig)

- self._dict[key] = val

- else:

- # The original is a list, so append the new

- # value to it (if there's a value to append).

- if val:

- add_to_orig(val)

- else:

- # The original looks like a dictionary, so update it

- # based on what we think the value looks like.

- if SCons.Util.is_List(val):

- for v in val:

- orig[v] = None

- else:

- try:

- update_dict(val)

- except (AttributeError, TypeError, ValueError):

- if SCons.Util.is_Dict(val):

- for k, v in val.items():

- orig[k] = v

- else:

- orig[val] = None

- self.scanner_map_delete(kw)

-

- # allow Dirs and strings beginning with # for top-relative

- # Note this uses the current env's fs (in self).

- def _canonicalize(self, path):

- if not SCons.Util.is_String(path): # typically a Dir

- path = str(path)

- if path and path[0] == '#':

- path = str(self.fs.Dir(path))

- return path

-

- def AppendENVPath(self, name, newpath, envname = 'ENV',

- sep = os.pathsep, delete_existing=1):

- """Append path elements to the path 'name' in the 'ENV'

- dictionary for this environment. Will only add any particular

- path once, and will normpath and normcase all paths to help

- assure this. This can also handle the case where the env

- variable is a list instead of a string.

-

- If delete_existing is 0, a newpath which is already in the path

- will not be moved to the end (it will be left where it is).

- """

-

- orig = ''

- if self._dict.has_key(envname) and self._dict[envname].has_key(name):

- orig = self._dict[envname][name]

-

- nv = SCons.Util.AppendPath(orig, newpath, sep, delete_existing,

- canonicalize=self._canonicalize)

-

- if not self._dict.has_key(envname):

- self._dict[envname] = {}

-

- self._dict[envname][name] = nv

-

- def AppendUnique(self, delete_existing=0, **kw):

- """Append values to existing construction variables

- in an Environment, if they're not already there.

- If delete_existing is 1, removes existing values first, so

- values move to end.

- """

- kw = copy_non_reserved_keywords(kw)

- for key, val in kw.items():

- if SCons.Util.is_List(val):

- val = _delete_duplicates(val, delete_existing)

- if not self._dict.has_key(key) or self._dict[key] in ('', None):

- self._dict[key] = val

- elif SCons.Util.is_Dict(self._dict[key]) and \

- SCons.Util.is_Dict(val):

- self._dict[key].update(val)

- elif SCons.Util.is_List(val):

- dk = self._dict[key]

- if not SCons.Util.is_List(dk):

- dk = [dk]

- if delete_existing:

- dk = filter(lambda x, val=val: x not in val, dk)

- else:

- val = filter(lambda x, dk=dk: x not in dk, val)

- self._dict[key] = dk + val

- else:

- dk = self._dict[key]

- if SCons.Util.is_List(dk):

- # By elimination, val is not a list. Since dk is a

- # list, wrap val in a list first.

- if delete_existing:

- dk = filter(lambda x, val=val: x not in val, dk)

- self._dict[key] = dk + [val]

- else:

- if not val in dk:

- self._dict[key] = dk + [val]

- else:

- if delete_existing:

- dk = filter(lambda x, val=val: x not in val, dk)

- self._dict[key] = dk + val

- self.scanner_map_delete(kw)

-

- def Clone(self, tools=[], toolpath=None, parse_flags = None, **kw):

- """Return a copy of a construction Environment. The

- copy is like a Python "deep copy"--that is, independent

- copies are made recursively of each objects--except that

- a reference is copied when an object is not deep-copyable

- (like a function). There are no references to any mutable

- objects in the original Environment.

- """

- clone = copy.copy(self)

- clone._dict = semi_deepcopy(self._dict)

-

- try:

- cbd = clone._dict['BUILDERS']

- except KeyError:

- pass

- else:

- clone._dict['BUILDERS'] = BuilderDict(cbd, clone)

-

- # Check the methods added via AddMethod() and re-bind them to

- # the cloned environment. Only do this if the attribute hasn't

- # been overwritten by the user explicitly and still points to

- # the added method.

- clone.added_methods = []

- for mw in self.added_methods:

- if mw == getattr(self, mw.name):

- clone.added_methods.append(mw.clone(clone))

-

- clone._memo = {}

-

- # Apply passed-in variables before the tools

- # so the tools can use the new variables

- kw = copy_non_reserved_keywords(kw)

- new = {}

- for key, value in kw.items():

- new[key] = SCons.Subst.scons_subst_once(value, self, key)

- apply(clone.Replace, (), new)

-

- apply_tools(clone, tools, toolpath)

-

- # apply them again in case the tools overwrote them

- apply(clone.Replace, (), new)

-

- # Finally, apply any flags to be merged in

- if parse_flags: clone.MergeFlags(parse_flags)

-

- if __debug__: logInstanceCreation(self, 'Environment.EnvironmentClone')

- return clone

-

- def Copy(self, *args, **kw):

- global _warn_copy_deprecated

- if _warn_copy_deprecated:

- msg = "The env.Copy() method is deprecated; use the env.Clone() method instead."

- SCons.Warnings.warn(SCons.Warnings.DeprecatedCopyWarning, msg)

- _warn_copy_deprecated = False

- return apply(self.Clone, args, kw)

-

- def _changed_build(self, dependency, target, prev_ni):

- if dependency.changed_state(target, prev_ni):

- return 1

- return self.decide_source(dependency, target, prev_ni)

-

- def _changed_content(self, dependency, target, prev_ni):

- return dependency.changed_content(target, prev_ni)

-

- def _changed_source(self, dependency, target, prev_ni):

- target_env = dependency.get_build_env()

- type = target_env.get_tgt_sig_type()

- if type == 'source':

- return target_env.decide_source(dependency, target, prev_ni)

- else:

- return target_env.decide_target(dependency, target, prev_ni)

-

- def _changed_timestamp_then_content(self, dependency, target, prev_ni):

- return dependency.changed_timestamp_then_content(target, prev_ni)

-

- def _changed_timestamp_newer(self, dependency, target, prev_ni):

- return dependency.changed_timestamp_newer(target, prev_ni)

-

- def _changed_timestamp_match(self, dependency, target, prev_ni):

- return dependency.changed_timestamp_match(target, prev_ni)

-

- def _copy_from_cache(self, src, dst):

- return self.fs.copy(src, dst)

-

- def _copy2_from_cache(self, src, dst):

- return self.fs.copy2(src, dst)

-

- def Decider(self, function):

- copy_function = self._copy2_from_cache

- if function in ('MD5', 'content'):

- if not SCons.Util.md5:

- raise UserError, "MD5 signatures are not available in this version of Python."

- function = self._changed_content

- elif function == 'MD5-timestamp':

- function = self._changed_timestamp_then_content

- elif function in ('timestamp-newer', 'make'):

- function = self._changed_timestamp_newer

- copy_function = self._copy_from_cache

- elif function == 'timestamp-match':

- function = self._changed_timestamp_match

- elif not callable(function):

- raise UserError, "Unknown Decider value %s" % repr(function)

-

- # We don't use AddMethod because we don't want to turn the

- # function, which only expects three arguments, into a bound

- # method, which would add self as an initial, fourth argument.

- self.decide_target = function

- self.decide_source = function

-

- self.copy_from_cache = copy_function

-

- def Detect(self, progs):

- """Return the first available program in progs.

- """

- if not SCons.Util.is_List(progs):

- progs = [ progs ]

- for prog in progs:

- path = self.WhereIs(prog)

- if path: return prog

- return None

-

- def Dictionary(self, *args):

- if not args:

- return self._dict

- dlist = map(lambda x, s=self: s._dict[x], args)

- if len(dlist) == 1:

- dlist = dlist[0]

- return dlist

-

- def Dump(self, key = None):

- """

- Using the standard Python pretty printer, dump the contents of the

- scons build environment to stdout.

-

- If the key passed in is anything other than None, then that will

- be used as an index into the build environment dictionary and

- whatever is found there will be fed into the pretty printer. Note

- that this key is case sensitive.

- """

- import pprint

- pp = pprint.PrettyPrinter(indent=2)

- if key:

- dict = self.Dictionary(key)

- else:

- dict = self.Dictionary()

- return pp.pformat(dict)

-

- def FindIxes(self, paths, prefix, suffix):

- """

- Search a list of paths for something that matches the prefix and suffix.

-

- paths - the list of paths or nodes.

- prefix - construction variable for the prefix.

- suffix - construction variable for the suffix.

- """

-

- suffix = self.subst('$'+suffix)

- prefix = self.subst('$'+prefix)

-

- for path in paths:

- dir,name = os.path.split(str(path))

- if name[:len(prefix)] == prefix and name[-len(suffix):] == suffix:

- return path

-

- def ParseConfig(self, command, function=None, unique=1):

- """

- Use the specified function to parse the output of the command

- in order to modify the current environment. The 'command' can

- be a string or a list of strings representing a command and

- its arguments. 'Function' is an optional argument that takes

- the environment, the output of the command, and the unique flag.

- If no function is specified, MergeFlags, which treats the output

- as the result of a typical 'X-config' command (i.e. gtk-config),

- will merge the output into the appropriate variables.

- """

- if function is None:

- def parse_conf(env, cmd, unique=unique):

- return env.MergeFlags(cmd, unique)

- function = parse_conf

- if SCons.Util.is_List(command):

- command = string.join(command)

- command = self.subst(command)

- return function(self, self.backtick(command))

-

- def ParseDepends(self, filename, must_exist=None, only_one=0):

- """

- Parse a mkdep-style file for explicit dependencies. This is

- completely abusable, and should be unnecessary in the "normal"

- case of proper SCons configuration, but it may help make

- the transition from a Make hierarchy easier for some people

- to swallow. It can also be genuinely useful when using a tool

- that can write a .d file, but for which writing a scanner would

- be too complicated.

- """

- filename = self.subst(filename)

- try:

- fp = open(filename, 'r')

- except IOError:

- if must_exist:

- raise

- return

- lines = SCons.Util.LogicalLines(fp).readlines()

- lines = filter(lambda l: l[0] != '#', lines)

- tdlist = []

- for line in lines:

- try:

- target, depends = string.split(line, ':', 1)

- except (AttributeError, TypeError, ValueError):

- # Python 1.5.2 throws TypeError if line isn't a string,

- # Python 2.x throws AttributeError because it tries

- # to call line.split(). Either can throw ValueError

- # if the line doesn't split into two or more elements.

- pass

- else:

- tdlist.append((string.split(target), string.split(depends)))

- if only_one:

- targets = reduce(lambda x, y: x+y, map(lambda p: p[0], tdlist))

- if len(targets) > 1:

- raise SCons.Errors.UserError, "More than one dependency target found in `%s': %s" % (filename, targets)

- for target, depends in tdlist:

- self.Depends(target, depends)

-

- def Platform(self, platform):

- platform = self.subst(platform)

- return SCons.Platform.Platform(platform)(self)

-

- def Prepend(self, **kw):

- """Prepend values to existing construction variables

- in an Environment.

- """

- kw = copy_non_reserved_keywords(kw)

- for key, val in kw.items():

- # It would be easier on the eyes to write this using

- # "continue" statements whenever we finish processing an item,

- # but Python 1.5.2 apparently doesn't let you use "continue"

- # within try:-except: blocks, so we have to nest our code.

- try:

- orig = self._dict[key]

- except KeyError:

- # No existing variable in the environment, so just set

- # it to the new value.

- self._dict[key] = val

- else:

- try:

- # Check if the original looks like a dictionary.

- # If it is, we can't just try adding the value because

- # dictionaries don't have __add__() methods, and

- # things like UserList will incorrectly coerce the

- # original dict to a list (which we don't want).

- update_dict = orig.update

- except AttributeError:

- try:

- # Most straightforward: just try to add them

- # together. This will work in most cases, when the

- # original and new values are of compatible types.

- self._dict[key] = val + orig

- except (KeyError, TypeError):

- try:

- # Check if the added value is a list.

- add_to_val = val.append

- except AttributeError:

- # The added value isn't a list, but the

- # original is (by process of elimination),

- # so insert the the new value in the original

- # (if there's one to insert).

- if val:

- orig.insert(0, val)

- else:

- # The added value is a list, so append

- # the original to it (if there's a value

- # to append).

- if orig:

- add_to_val(orig)

- self._dict[key] = val

- else:

- # The original looks like a dictionary, so update it

- # based on what we think the value looks like.

- if SCons.Util.is_List(val):

- for v in val:

- orig[v] = None

- else:

- try:

- update_dict(val)

- except (AttributeError, TypeError, ValueError):

- if SCons.Util.is_Dict(val):

- for k, v in val.items():

- orig[k] = v

- else:

- orig[val] = None

- self.scanner_map_delete(kw)

-

- def PrependENVPath(self, name, newpath, envname = 'ENV', sep = os.pathsep,

- delete_existing=1):

- """Prepend path elements to the path 'name' in the 'ENV'

- dictionary for this environment. Will only add any particular

- path once, and will normpath and normcase all paths to help

- assure this. This can also handle the case where the env

- variable is a list instead of a string.

-

- If delete_existing is 0, a newpath which is already in the path

- will not be moved to the front (it will be left where it is).

- """

-

- orig = ''

- if self._dict.has_key(envname) and self._dict[envname].has_key(name):

- orig = self._dict[envname][name]

-

- nv = SCons.Util.PrependPath(orig, newpath, sep, delete_existing,

- canonicalize=self._canonicalize)

-

- if not self._dict.has_key(envname):

- self._dict[envname] = {}

-

- self._dict[envname][name] = nv

-

- def PrependUnique(self, delete_existing=0, **kw):

- """Prepend values to existing construction variables

- in an Environment, if they're not already there.

- If delete_existing is 1, removes existing values first, so

- values move to front.

- """

- kw = copy_non_reserved_keywords(kw)

- for key, val in kw.items():

- if SCons.Util.is_List(val):

- val = _delete_duplicates(val, not delete_existing)

- if not self._dict.has_key(key) or self._dict[key] in ('', None):

- self._dict[key] = val

- elif SCons.Util.is_Dict(self._dict[key]) and \

- SCons.Util.is_Dict(val):

- self._dict[key].update(val)

- elif SCons.Util.is_List(val):

- dk = self._dict[key]

- if not SCons.Util.is_List(dk):

- dk = [dk]

- if delete_existing:

- dk = filter(lambda x, val=val: x not in val, dk)

- else:

- val = filter(lambda x, dk=dk: x not in dk, val)

- self._dict[key] = val + dk

- else:

- dk = self._dict[key]

- if SCons.Util.is_List(dk):

- # By elimination, val is not a list. Since dk is a

- # list, wrap val in a list first.

- if delete_existing:

- dk = filter(lambda x, val=val: x not in val, dk)

- self._dict[key] = [val] + dk

- else:

- if not val in dk:

- self._dict[key] = [val] + dk

- else:

- if delete_existing:

- dk = filter(lambda x, val=val: x not in val, dk)

- self._dict[key] = val + dk

- self.scanner_map_delete(kw)

-

- def Replace(self, **kw):

- """Replace existing construction variables in an Environment

- with new construction variables and/or values.

- """

- try:

- kwbd = kw['BUILDERS']

- except KeyError:

- pass

- else:

- kwbd = semi_deepcopy(kwbd)

- del kw['BUILDERS']

- self.__setitem__('BUILDERS', kwbd)

- kw = copy_non_reserved_keywords(kw)

- self._update(semi_deepcopy(kw))

- self.scanner_map_delete(kw)

-

- def ReplaceIxes(self, path, old_prefix, old_suffix, new_prefix, new_suffix):

- """

- Replace old_prefix with new_prefix and old_suffix with new_suffix.

-

- env - Environment used to interpolate variables.

- path - the path that will be modified.

- old_prefix - construction variable for the old prefix.

- old_suffix - construction variable for the old suffix.

- new_prefix - construction variable for the new prefix.

- new_suffix - construction variable for the new suffix.

- """

- old_prefix = self.subst('$'+old_prefix)

- old_suffix = self.subst('$'+old_suffix)

-

- new_prefix = self.subst('$'+new_prefix)

- new_suffix = self.subst('$'+new_suffix)

-

- dir,name = os.path.split(str(path))

- if name[:len(old_prefix)] == old_prefix:

- name = name[len(old_prefix):]

- if name[-len(old_suffix):] == old_suffix:

- name = name[:-len(old_suffix)]

- return os.path.join(dir, new_prefix+name+new_suffix)

-

- def SetDefault(self, **kw):

- for k in kw.keys():

- if self._dict.has_key(k):

- del kw[k]

- apply(self.Replace, (), kw)

-

- def _find_toolpath_dir(self, tp):

- return self.fs.Dir(self.subst(tp)).srcnode().abspath

-

- def Tool(self, tool, toolpath=None, **kw):

- if SCons.Util.is_String(tool):

- tool = self.subst(tool)

- if toolpath is None:

- toolpath = self.get('toolpath', [])

- toolpath = map(self._find_toolpath_dir, toolpath)

- tool = apply(SCons.Tool.Tool, (tool, toolpath), kw)

- tool(self)

-

- def WhereIs(self, prog, path=None, pathext=None, reject=[]):

- """Find prog in the path.

- """

- if path is None:

- try:

- path = self['ENV']['PATH']

- except KeyError:

- pass

- elif SCons.Util.is_String(path):

- path = self.subst(path)

- if pathext is None:

- try:

- pathext = self['ENV']['PATHEXT']

- except KeyError:

- pass

- elif SCons.Util.is_String(pathext):

- pathext = self.subst(pathext)

- prog = self.subst(prog)

- path = SCons.Util.WhereIs(prog, path, pathext, reject)

- if path: return path

- return None

-

- #######################################################################

- # Public methods for doing real "SCons stuff" (manipulating

- # dependencies, setting attributes on targets, etc.). These begin

- # with upper-case letters. The essential characteristic of methods

- # in this section is that they all *should* have corresponding

- # same-named global functions.

- #######################################################################

-

- def Action(self, *args, **kw):

- def subst_string(a, self=self):

- if SCons.Util.is_String(a):

- a = self.subst(a)

- return a

- nargs = map(subst_string, args)

- nkw = self.subst_kw(kw)

- return apply(SCons.Action.Action, nargs, nkw)

-

- def AddPreAction(self, files, action):

- nodes = self.arg2nodes(files, self.fs.Entry)

- action = SCons.Action.Action(action)

- uniq = {}

- for executor in map(lambda n: n.get_executor(), nodes):

- uniq[executor] = 1

- for executor in uniq.keys():

- executor.add_pre_action(action)

- return nodes

-

- def AddPostAction(self, files, action):

- nodes = self.arg2nodes(files, self.fs.Entry)

- action = SCons.Action.Action(action)

- uniq = {}

- for executor in map(lambda n: n.get_executor(), nodes):

- uniq[executor] = 1

- for executor in uniq.keys():

- executor.add_post_action(action)

- return nodes

-

- def Alias(self, target, source=[], action=None, **kw):

- tlist = self.arg2nodes(target, self.ans.Alias)

- if not SCons.Util.is_List(source):

- source = [source]

- source = filter(None, source)

-

- if not action:

- if not source:

- # There are no source files and no action, so just

- # return a target list of classic Alias Nodes, without

- # any builder. The externally visible effect is that