__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
-
import copy
import os
import os.path
import re
-import stat
-import string
import sys
import types
-import UserDict
-import UserList
-import SCons.Node
-try:
- from UserString import UserString
-except ImportError:
- class UserString:
- pass
+from UserDict import UserDict
+from UserList import UserList
+from UserString import UserString
+
+# Don't "from types import ..." these because we need to get at the
+# types module later to look for UnicodeType.
+DictType = dict
+InstanceType = types.InstanceType
+ListType = list
+StringType = str
+TupleType = tuple
+try: unicode
+except NameError: UnicodeType = None
+else: UnicodeType = unicode
+
+def dictify(keys, values, result={}):
+ for k, v in zip(keys, values):
+ result[k] = v
+ return result
_altsep = os.altsep
if _altsep is None and sys.platform == 'win32':
# My ActivePython 2.0.1 doesn't set os.altsep! What gives?
_altsep = '/'
+if _altsep:
+ def rightmost_separator(path, sep):
+ return max(path.rfind(sep), path.rfind(_altsep))
+else:
+ def rightmost_separator(path, sep):
+ return path.rfind(sep)
+
+# First two from the Python Cookbook, just for completeness.
+# (Yeah, yeah, YAGNI...)
+def containsAny(str, set):
+ """Check whether sequence str contains ANY of the items in set."""
+ for c in set:
+ if c in str: return 1
+ return 0
+
+def containsAll(str, set):
+ """Check whether sequence str contains ALL of the items in set."""
+ for c in set:
+ if c not in str: return 0
+ return 1
+
+def containsOnly(str, set):
+ """Check whether sequence str contains ONLY items in set."""
+ for c in str:
+ if c not in set: return 0
+ return 1
def splitext(path):
"Same as os.path.splitext() but faster."
- if _altsep:
- sep = max(string.rfind(path, os.sep), string.rfind(path, _altsep))
- else:
- sep = string.rfind(path, os.sep)
- dot = string.rfind(path, '.')
- if dot > sep:
+ sep = rightmost_separator(path, os.sep)
+ dot = path.rfind('.')
+ # An ext is only real if it has at least one non-digit char
+ if dot > sep and not containsOnly(path[dot:], "0123456789."):
return path[:dot],path[dot:]
else:
return path,""
"""
drive, rest = os.path.splitdrive(path)
if drive:
- path = string.upper(drive) + rest
+ path = drive.upper() + rest
return path
-if hasattr(types, 'UnicodeType'):
- def to_String(s):
- if isinstance(s, UserString):
- t = type(s.data)
- else:
- t = type(s)
- if t is types.UnicodeType:
- return unicode(s)
- else:
- return str(s)
-else:
- to_String = str
-
-class Literal:
- """A wrapper for a string. If you use this object wrapped
- around a string, then it will be interpreted as literal.
- When passed to the command interpreter, all special
- characters will be escaped."""
- def __init__(self, lstr):
- self.lstr = lstr
-
- def __str__(self):
- return self.lstr
-
- def is_literal(self):
- return 1
-
-class SpecialAttrWrapper(Literal):
- """This is a wrapper for what we call a 'Node special attribute.'
- This is any of the attributes of a Node that we can reference from
- Environment variable substitution, such as $TARGET.abspath or
- $SOURCES[1].filebase. We inherit from Literal so we can handle
- special characters, plus we implement a for_signature method,
- such that we can return some canonical string during signatutre
- calculation to avoid unnecessary rebuilds."""
-
- def __init__(self, lstr, for_signature=None):
- """The for_signature parameter, if supplied, will be the
- canonical string we return from for_signature(). Else
- we will simply return lstr."""
- Literal.__init__(self, lstr)
- if for_signature:
- self.forsig = for_signature
- else:
- self.forsig = lstr
-
- def for_signature(self):
- return self.forsig
-
-class CallableComposite(UserList.UserList):
- """A simple composite callable class that, when called, will invoke all
- of its contained callables with the same arguments."""
- def __init__(self, seq = []):
- UserList.UserList.__init__(self, seq)
-
- def __call__(self, *args, **kwargs):
- retvals = map(lambda x, args=args, kwargs=kwargs: apply(x,
- args,
- kwargs),
- self.data)
- if self.data and (len(self.data) == len(filter(callable, retvals))):
- return self.__class__(retvals)
- return NodeList(retvals)
-
-class NodeList(UserList.UserList):
+class NodeList(UserList):
"""This class is almost exactly like a regular list of Nodes
(actually it can hold any object), with one important difference.
If you try to get an attribute from this list, it will return that
>>> someList.strip()
[ 'foo', 'bar' ]
"""
- def __init__(self, seq = []):
- UserList.UserList.__init__(self, seq)
-
def __nonzero__(self):
return len(self.data) != 0
def __str__(self):
- return string.join(map(str, self.data))
+ return ' '.join(map(str, self.data))
+
+ def __iter__(self):
+ return iter(self.data)
+
+ def __call__(self, *args, **kwargs):
+ result = [x(*args, **kwargs) for x in self.data]
+ return self.__class__(result)
def __getattr__(self, name):
- if not self.data:
- # If there is nothing in the list, then we have no attributes to
- # pass through, so raise AttributeError for everything.
- raise AttributeError, "NodeList has no attribute: %s" % name
-
- # Return a list of the attribute, gotten from every element
- # in the list
- attrList = map(lambda x, n=name: getattr(x, n), self.data)
-
- # Special case. If the attribute is callable, we do not want
- # to return a list of callables. Rather, we want to return a
- # single callable that, when called, will invoke the function on
- # all elements of this list.
- if self.data and (len(self.data) == len(filter(callable, attrList))):
- return CallableComposite(attrList)
- return self.__class__(attrList)
-
- def is_literal(self):
- return 1
-
-_valid_var = re.compile(r'[_a-zA-Z]\w*$')
-_get_env_var = re.compile(r'^\$([_a-zA-Z]\w*|{[_a-zA-Z]\w*})$')
+ result = [getattr(x, name) for x in self.data]
+ return self.__class__(result)
-def is_valid_construction_var(varstr):
- """Return if the specified string is a legitimate construction
- variable.
- """
- return _valid_var.match(varstr)
+
+_get_env_var = re.compile(r'^\$([_a-zA-Z]\w*|{[_a-zA-Z]\w*})$')
def get_environment_var(varstr):
"""Given a string, first determine if it looks like a reference
else:
return None
-def quote_spaces(arg):
- if ' ' in arg or '\t' in arg:
- return '"%s"' % arg
- else:
- return str(arg)
-
-# Several functions below deal with Environment variable
-# substitution. Part of this process involves inserting
-# a bunch of special escape sequences into the string
-# so that when we are all done, we know things like
-# where to split command line args, what strings to
-# interpret literally, etc. A dictionary of these
-# sequences follows:
-#
-# \0\1 signifies a division between arguments in
-# a command line.
-#
-# \0\2 signifies a division between multiple distinct
-# commands, i.e., a newline
-#
-# \0\3 This string should be interpreted literally.
-# This code occurring anywhere in the string means
-# the whole string should have all special characters
-# escaped.
-#
-# \0\4 A literal dollar sign '$'
-#
-# \0\5 Placed before and after interpolated variables
-# so that we do not accidentally smush two variables
-# together during the recursive interpolation process.
-
-_cv = re.compile(r'\$([_a-zA-Z][\.\w]*|{[^}]*})')
-_space_sep = re.compile(r'[\t ]+(?![^{]*})')
-_newline = re.compile(r'[\r\n]+')
-
-def _convertArg(x, strconv=to_String):
- """This function converts an individual argument. If the
- argument is to be interpreted literally, with all special
- characters escaped, then we insert a special code in front
- of it, so that the command interpreter will know this."""
- literal = 0
-
- try:
- if x.is_literal():
- literal = 1
- except AttributeError:
- pass
-
- if not literal:
- # escape newlines as '\0\2', '\0\1' denotes an argument split
- # Also escape double-dollar signs to mean the literal dollar sign.
- return string.replace(_newline.sub('\0\2', strconv(x)), '$$', '\0\4')
- else:
- # Interpret non-string args as literals.
- # The special \0\3 code will tell us to encase this string
- # in a Literal instance when we are all done
- # Also escape out any $ signs because we don't want
- # to continue interpolating a literal.
- return '\0\3' + string.replace(strconv(x), '$', '\0\4')
-
-def _convert(x, strconv = to_String):
- """This function is used to convert construction variable
- values or the value of strSubst to a string for interpolation.
- This function follows the rules outlined in the documentaion
- for scons_subst_list()"""
- if x is None:
- return ''
- elif is_String(x):
- # escape newlines as '\0\2', '\0\1' denotes an argument split
- return _convertArg(_space_sep.sub('\0\1', x), strconv)
- elif is_List(x):
- # '\0\1' denotes an argument split
- return string.join(map(lambda x, s=strconv: _convertArg(x, s), x),
- '\0\1')
- else:
- return _convertArg(x, strconv)
-
-class CmdStringHolder:
- """This is a special class used to hold strings generated
- by scons_subst_list(). It defines a special method escape().
- When passed a function with an escape algorithm for a
- particular platform, it will return the contained string
- with the proper escape sequences inserted."""
-
- def __init__(self, cmd):
- """This constructor receives a string. The string
- can contain the escape sequence \0\3.
- If it does, then we will escape all special characters
- in the string before passing it to the command interpreter."""
- self.data = cmd
-
- # Populate flatdata (the thing returned by str()) with the
- # non-escaped string
- self.escape(lambda x: x, lambda x: x)
-
- def __str__(self):
- """Return the string in its current state."""
- return self.flatdata
-
- def __len__(self):
- """Return the length of the string in its current state."""
- return len(self.flatdata)
-
- def __getitem__(self, index):
- """Return the index'th element of the string in its current state."""
- return self.flatdata[index]
-
- def escape(self, escape_func, quote_func=quote_spaces):
- """Escape the string with the supplied function. The
- function is expected to take an arbitrary string, then
- return it with all special characters escaped and ready
- for passing to the command interpreter.
-
- After calling this function, the next call to str() will
- return the escaped string.
- """
-
- if string.find(self.data, '\0\3') >= 0:
- self.flatdata = escape_func(string.replace(self.data, '\0\3', ''))
- elif ' ' in self.data or '\t' in self.data:
- self.flatdata = quote_func(self.data)
- else:
- self.flatdata = self.data
-
- def __cmp__(self, rhs):
- return cmp(self.flatdata, str(rhs))
-
class DisplayEngine:
def __init__(self):
self.__call__ = self.print_it
- def print_it(self, text):
- print text
+ def print_it(self, text, append_newline=1):
+ if append_newline: text = text + '\n'
+ try:
+ sys.stdout.write(text)
+ except IOError:
+ # Stdout might be connected to a pipe that has been closed
+ # by now. The most likely reason for the pipe being closed
+ # is that the user has press ctrl-c. It this is the case,
+ # then SCons is currently shutdown. We therefore ignore
+ # IOError's here so that SCons can continue and shutdown
+ # properly so that the .sconsign is correctly written
+ # before SCons exits.
+ pass
- def dont_print(self, text):
+ def dont_print(self, text, append_newline=1):
pass
def set_mode(self, mode):
else:
self.__call__ = self.dont_print
-def target_prep(target):
- if target and not isinstance(target, NodeList):
- if not is_List(target):
- target = [target]
- target = NodeList(map(lambda x: x.get_subst_proxy(), target))
- return target
-
-def source_prep(source):
- if source and not isinstance(source, NodeList):
- if not is_List(source):
- source = [source]
- source = NodeList(map(lambda x: x.rfile().get_subst_proxy(), source))
- return source
-
-def subst_dict(target, source, env):
- """Create a dictionary for substitution of special
- construction variables.
-
- This translates the following special arguments:
-
- target - the target (object or array of objects),
- used to generate the TARGET and TARGETS
- construction variables
-
- source - the source (object or array of objects),
- used to generate the SOURCES and SOURCE
- construction variables
-
- env - the construction Environment used for this
- build, which is made available as the __env__
- construction variable
- """
- dict = { '__env__' : env }
-
- target = target_prep(target)
- dict['TARGETS'] = target
- if dict['TARGETS']:
- dict['TARGET'] = dict['TARGETS'][0]
-
- source = source_prep(source)
- dict['SOURCES'] = source
- if dict['SOURCES']:
- dict['SOURCE'] = dict['SOURCES'][0]
-
- return dict
-
-# Constants for the "mode" parameter to scons_subst_list() and
-# scons_subst(). SUBST_RAW gives the raw command line. SUBST_CMD
-# gives a command line suitable for passing to a shell. SUBST_SIG
-# gives a command line appropriate for calculating the signature
-# of a command line...if this changes, we should rebuild.
-SUBST_RAW = 0
-SUBST_CMD = 1
-SUBST_SIG = 2
-
-_rm = re.compile(r'\$[()]')
-_remove = re.compile(r'\$\(([^\$]|\$[^\(])*?\$\)')
-
-def _canonicalize(obj):
- """Attempt to call the object's for_signature method,
- which is expected to return a string suitable for use in calculating
- a command line signature (i.e., it only changes when we should
- rebuild the target). For instance, file Nodes will report only
- their file name (with no path), so changing Repository settings
- will not cause a rebuild."""
- try:
- return obj.for_signature()
- except AttributeError:
- return to_String(obj)
-
-# Indexed by the SUBST_* constants above.
-_regex_remove = [ None, _rm, _remove ]
-_strconv = [ to_String, to_String, _canonicalize ]
-
-def scons_subst_list(strSubst, env, mode=SUBST_RAW, target=None, source=None):
- """
- This function serves the same purpose as scons_subst(), except
- this function returns the interpolated list as a list of lines, where
- each line is a list of command line arguments. In other words:
- The first (outer) list is a list of lines, where the
- substituted stirng has been broken along newline characters.
- The inner lists are lists of command line arguments, i.e.,
- the argv array that should be passed to a spawn or exec
- function.
-
- There are a few simple rules this function follows in order to
- determine how to parse strSubst and construction variables into lines
- and arguments:
-
- 1) A string is interpreted as a space delimited list of arguments.
- 2) A list is interpreted as a list of arguments. This allows arguments
- with spaces in them to be expressed easily.
- 4) Anything that is not a list or string (e.g. a Node instance) is
- interpreted as a single argument, and is converted to a string.
- 3) Newline (\n) characters delimit lines. The newline parsing is done
- after all the other parsing, so it is not possible for arguments
- (e.g. file names) to contain embedded newline characters.
- """
-
- remove = _regex_remove[mode]
- strconv = _strconv[mode]
-
- def repl(m,
- target=target,
- source=source,
- env=env,
- local_vars = subst_dict(target, source, env),
- global_vars = env.Dictionary(),
- strconv=strconv,
- sig=(mode != SUBST_CMD)):
- key = m.group(1)
- if key[0] == '{':
- key = key[1:-1]
- try:
- e = eval(key, global_vars, local_vars)
- except (IndexError, NameError, TypeError):
- return '\0\5'
- if callable(e):
- # We wait to evaluate callables until the end of everything
- # else. For now, we instert a special escape sequence
- # that we will look for later.
- return '\0\5' + _convert(e(target=target,
- source=source,
- env=env,
- for_signature=sig),
- strconv) + '\0\5'
- else:
- # The \0\5 escape code keeps us from smushing two or more
- # variables together during recusrive substitution, i.e.
- # foo=$bar bar=baz barbaz=blat => $foo$bar->blat (bad)
- return "\0\5" + _convert(e, strconv) + "\0\5"
-
- # Convert the argument to a string:
- strSubst = _convert(strSubst, strconv)
-
- # Do the interpolation:
- n = 1
- while n != 0:
- strSubst, n = _cv.subn(repl, strSubst)
-
- # Convert the interpolated string to a list of lines:
- listLines = string.split(strSubst, '\0\2')
-
- # Remove the patterns that match the remove argument:
- if remove:
- listLines = map(lambda x,re=remove: re.sub('', x), listLines)
-
- # Process escaped $'s and remove placeholder \0\5's
- listLines = map(lambda x: string.replace(string.replace(x, '\0\4', '$'), '\0\5', ''), listLines)
-
- # Finally split each line up into a list of arguments:
- return map(lambda x: map(CmdStringHolder, filter(lambda y:y, string.split(x, '\0\1'))),
- listLines)
-
-def scons_subst(strSubst, env, mode=SUBST_RAW, target=None, source=None):
- """Recursively interpolates dictionary variables into
- the specified string, returning the expanded result.
- 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.
- """
-
- # This function needs to be fast, so don't call scons_subst_list
-
- remove = _regex_remove[mode]
- strconv = _strconv[mode]
-
- def repl(m,
- target=target,
- source=source,
- env=env,
- local_vars = subst_dict(target, source, env),
- global_vars = env.Dictionary(),
- strconv=strconv,
- sig=(mode != SUBST_CMD)):
- key = m.group(1)
- if key[0] == '{':
- key = key[1:-1]
- try:
- e = eval(key, global_vars, local_vars)
- except (IndexError, NameError, TypeError):
- return '\0\5'
- if callable(e):
- e = e(target=target, source=source, env=env,
- for_signature = sig)
-
- def conv(arg, strconv=strconv):
- literal = 0
- try:
- if arg.is_literal():
- literal = 1
- except AttributeError:
- pass
- ret = strconv(arg)
- if literal:
- # Escape dollar signs to prevent further
- # substitution on literals.
- ret = string.replace(ret, '$', '\0\4')
- return ret
- if e is None:
- s = ''
- elif is_List(e):
- s = string.join(map(conv, e), ' ')
- else:
- s = conv(e)
- # Insert placeholders to avoid accidentally smushing
- # separate variables together.
- return "\0\5" + s + "\0\5"
-
- # Now, do the substitution
- n = 1
- while n != 0:
- # escape double dollar signs
- strSubst = string.replace(strSubst, '$$', '\0\4')
- strSubst,n = _cv.subn(repl, strSubst)
-
- # remove the remove regex
- if remove:
- strSubst = remove.sub('', strSubst)
-
- # Un-escape the string
- strSubst = string.replace(string.replace(strSubst, '\0\4', '$'),
- '\0\5', '')
- # strip out redundant white-space
- return string.strip(_space_sep.sub(' ', strSubst))
-
def render_tree(root, child_func, prune=0, margin=[0], visited={}):
"""
Render a tree of nodes into an ASCII tree view.
or in the whole tree if prune.
"""
- if visited.has_key(root):
- return ""
+ rname = str(root)
children = child_func(root)
retval = ""
else:
retval = retval + " "
- retval = retval + "+-" + str(root) + "\n"
+ if rname in visited:
+ return retval + "+-[" + rname + "]\n"
+
+ retval = retval + "+-" + rname + "\n"
if not prune:
visited = copy.copy(visited)
- visited[root] = 1
+ visited[rname] = 1
for i in range(len(children)):
margin.append(i<len(children)-1)
return retval
-def is_Dict(e):
- return type(e) is types.DictType or isinstance(e, UserDict.UserDict)
+IDX = lambda N: N and 1 or 0
-def is_List(e):
- return type(e) is types.ListType or isinstance(e, UserList.UserList)
+def print_tree(root, child_func, prune=0, showtags=0, margin=[0], visited={}):
+ """
+ Print a tree of nodes. This is like render_tree, except it prints
+ lines directly instead of creating a string representation in memory,
+ so that huge trees can be printed.
-def argmunge(arg):
- return Split(arg)
+ root - the root node of the tree
+ child_func - the function called to get the children of a node
+ prune - don't visit the same node twice
+ showtags - print status information to the left of each node line
+ margin - the format of the left margin to use for children of root.
+ 1 results in a pipe, and 0 results in no pipe.
+ visited - a dictionary of visited nodes in the current branch if not prune,
+ or in the whole tree if prune.
+ """
+
+ rname = str(root)
+
+ if showtags:
+
+ if showtags == 2:
+ print ' E = exists'
+ print ' R = exists in repository only'
+ print ' b = implicit builder'
+ print ' B = explicit builder'
+ print ' S = side effect'
+ print ' P = precious'
+ print ' A = always build'
+ print ' C = current'
+ print ' N = no clean'
+ print ' H = no cache'
+ print ''
+
+ tags = ['[']
+ tags.append(' E'[IDX(root.exists())])
+ tags.append(' R'[IDX(root.rexists() and not root.exists())])
+ tags.append(' BbB'[[0,1][IDX(root.has_explicit_builder())] +
+ [0,2][IDX(root.has_builder())]])
+ tags.append(' S'[IDX(root.side_effect)])
+ tags.append(' P'[IDX(root.precious)])
+ tags.append(' A'[IDX(root.always_build)])
+ tags.append(' C'[IDX(root.is_up_to_date())])
+ tags.append(' N'[IDX(root.noclean)])
+ tags.append(' H'[IDX(root.nocache)])
+ tags.append(']')
-def Split(arg):
- """This function converts a string or list into a list of strings
- or Nodes. This makes things easier for users by allowing files to
- be specified as a white-space separated list to be split.
- The input rules are:
- - A single string containing names separated by spaces. These will be
- split apart at the spaces.
- - A single Node instance
- - A list containing either strings or Node instances. Any strings
- in the list are not split at spaces.
- In all cases, the function returns a list of Nodes and strings."""
- if is_List(arg):
- return arg
- elif is_String(arg):
- return string.split(arg)
else:
- return [arg]
+ tags = []
-def mapPaths(paths, dir, env=None):
- """Takes a single node or string, or a list of nodes and/or
- strings. We leave the nodes untouched, but we put the strings
- under the supplied directory node dir, if they are not an absolute
- path.
+ def MMM(m):
+ return [" ","| "][m]
+ margins = list(map(MMM, margin[:-1]))
- For instance, the following:
+ children = child_func(root)
- n = SCons.Node.FS.default_fs.File('foo')
- mapPaths([ n, 'foo', '/bar' ],
- SCons.Node.FS.default_fs.Dir('baz'), env)
+ if prune and rname in visited and children:
+ print ''.join(tags + margins + ['+-[', rname, ']'])
+ return
- ...would return:
+ print ''.join(tags + margins + ['+-', rname])
- [ n, 'baz/foo', '/bar' ]
+ visited[rname] = 1
- The env argument, if given, is used to perform variable
- substitution on the source string(s).
- """
+ if children:
+ margin.append(1)
+ idx = IDX(showtags)
+ for C in children[:-1]:
+ print_tree(C, child_func, prune, idx, margin, visited)
+ margin[-1] = 0
+ print_tree(children[-1], child_func, prune, idx, margin, visited)
+ margin.pop()
- def mapPathFunc(path, dir=dir, env=env):
- if is_String(path):
- if env:
- path = env.subst(path)
- if dir:
- if not path:
- return str(dir)
- if os.path.isabs(path) or path[0] == '#':
- return path
- return str(dir) + os.sep + path
- return path
- if not is_List(paths):
- paths = [ paths ]
- ret = map(mapPathFunc, paths)
- return ret
-
-
-if hasattr(types, 'UnicodeType'):
- def is_String(e):
- return type(e) is types.StringType \
- or type(e) is types.UnicodeType \
- or isinstance(e, UserString)
+
+# Functions for deciding if things are like various types, mainly to
+# handle UserDict, UserList and UserString like their underlying types.
+#
+# Yes, all of this manual testing breaks polymorphism, and the real
+# Pythonic way to do all of this would be to just try it and handle the
+# exception, but handling the exception when it's not the right type is
+# often too slow.
+
+try:
+ class mystr(str):
+ pass
+except TypeError:
+ # An older Python version without new-style classes.
+ #
+ # The actual implementations here have been selected after timings
+ # coded up in in bench/is_types.py (from the SCons source tree,
+ # see the scons-src distribution), mostly against Python 1.5.2.
+ # Key results from those timings:
+ #
+ # -- Storing the type of the object in a variable (t = type(obj))
+ # slows down the case where it's a native type and the first
+ # comparison will match, but nicely speeds up the case where
+ # it's a different native type. Since that's going to be
+ # common, it's a good tradeoff.
+ #
+ # -- The data show that calling isinstance() on an object that's
+ # a native type (dict, list or string) is expensive enough
+ # that checking up front for whether the object is of type
+ # InstanceType is a pretty big win, even though it does slow
+ # down the case where it really *is* an object instance a
+ # little bit.
+ def is_Dict(obj):
+ t = type(obj)
+ return t is DictType or \
+ (t is InstanceType and isinstance(obj, UserDict))
+
+ def is_List(obj):
+ t = type(obj)
+ return t is ListType \
+ or (t is InstanceType and isinstance(obj, UserList))
+
+ def is_Sequence(obj):
+ t = type(obj)
+ return t is ListType \
+ or t is TupleType \
+ or (t is InstanceType and isinstance(obj, UserList))
+
+ def is_Tuple(obj):
+ t = type(obj)
+ return t is TupleType
+
+ if UnicodeType is not None:
+ def is_String(obj):
+ t = type(obj)
+ return t is StringType \
+ or t is UnicodeType \
+ or (t is InstanceType and isinstance(obj, UserString))
+ else:
+ def is_String(obj):
+ t = type(obj)
+ return t is StringType \
+ or (t is InstanceType and isinstance(obj, UserString))
+
+ def is_Scalar(obj):
+ return is_String(obj) or not is_Sequence(obj)
+
+ def flatten(obj, result=None):
+ """Flatten a sequence to a non-nested list.
+
+ Flatten() converts either a single scalar or a nested sequence
+ to a non-nested list. Note that flatten() considers strings
+ to be scalars instead of sequences like Python would.
+ """
+ if is_Scalar(obj):
+ return [obj]
+ if result is None:
+ result = []
+ for item in obj:
+ if is_Scalar(item):
+ result.append(item)
+ else:
+ flatten_sequence(item, result)
+ return result
+
+ def flatten_sequence(sequence, result=None):
+ """Flatten a sequence to a non-nested list.
+
+ Same as flatten(), but it does not handle the single scalar
+ case. This is slightly more efficient when one knows that
+ the sequence to flatten can not be a scalar.
+ """
+ if result is None:
+ result = []
+ for item in sequence:
+ if is_Scalar(item):
+ result.append(item)
+ else:
+ flatten_sequence(item, result)
+ return result
+
+ #
+ # Generic convert-to-string functions that abstract away whether or
+ # not the Python we're executing has Unicode support. The wrapper
+ # to_String_for_signature() will use a for_signature() method if the
+ # specified object has one.
+ #
+ if UnicodeType is not None:
+ def to_String(s):
+ if isinstance(s, UserString):
+ t = type(s.data)
+ else:
+ t = type(s)
+ if t is UnicodeType:
+ return unicode(s)
+ else:
+ return str(s)
+ else:
+ to_String = str
+
+ def to_String_for_signature(obj):
+ try:
+ f = obj.for_signature
+ except AttributeError:
+ return to_String_for_subst(obj)
+ else:
+ return f()
+
+ def to_String_for_subst(s):
+ if is_Sequence( s ):
+ return ' '.join( map(to_String_for_subst, s) )
+
+ return to_String( s )
+
else:
- def is_String(e):
- return type(e) is types.StringType or isinstance(e, UserString)
+ # A modern Python version with new-style classes, so we can just use
+ # isinstance().
+ #
+ # We are using the following trick to speed-up these
+ # functions. Default arguments are used to take a snapshot of the
+ # the global functions and constants used by these functions. This
+ # transforms accesses to global variable into local variables
+ # accesses (i.e. LOAD_FAST instead of LOAD_GLOBAL).
+
+ DictTypes = (dict, UserDict)
+ ListTypes = (list, UserList)
+ SequenceTypes = (list, tuple, UserList)
+
+ # Empirically, Python versions with new-style classes all have
+ # unicode.
+ #
+ # Note that profiling data shows a speed-up when comparing
+ # explicitely with str and unicode instead of simply comparing
+ # with basestring. (at least on Python 2.5.1)
+ StringTypes = (str, unicode, UserString)
+
+ # Empirically, it is faster to check explicitely for str and
+ # unicode than for basestring.
+ BaseStringTypes = (str, unicode)
+
+ def is_Dict(obj, isinstance=isinstance, DictTypes=DictTypes):
+ return isinstance(obj, DictTypes)
+
+ def is_List(obj, isinstance=isinstance, ListTypes=ListTypes):
+ return isinstance(obj, ListTypes)
+
+ def is_Sequence(obj, isinstance=isinstance, SequenceTypes=SequenceTypes):
+ return isinstance(obj, SequenceTypes)
+
+ def is_Tuple(obj, isinstance=isinstance, tuple=tuple):
+ return isinstance(obj, tuple)
+
+ def is_String(obj, isinstance=isinstance, StringTypes=StringTypes):
+ return isinstance(obj, StringTypes)
+
+ def is_Scalar(obj, isinstance=isinstance, StringTypes=StringTypes, SequenceTypes=SequenceTypes):
+ # Profiling shows that there is an impressive speed-up of 2x
+ # when explicitely checking for strings instead of just not
+ # sequence when the argument (i.e. obj) is already a string.
+ # But, if obj is a not string than it is twice as fast to
+ # check only for 'not sequence'. The following code therefore
+ # assumes that the obj argument is a string must of the time.
+ return isinstance(obj, StringTypes) or not isinstance(obj, SequenceTypes)
+
+ def do_flatten(sequence, result, isinstance=isinstance,
+ StringTypes=StringTypes, SequenceTypes=SequenceTypes):
+ for item in sequence:
+ if isinstance(item, StringTypes) or not isinstance(item, SequenceTypes):
+ result.append(item)
+ else:
+ do_flatten(item, result)
+
+ def flatten(obj, isinstance=isinstance, StringTypes=StringTypes,
+ SequenceTypes=SequenceTypes, do_flatten=do_flatten):
+ """Flatten a sequence to a non-nested list.
+
+ Flatten() converts either a single scalar or a nested sequence
+ to a non-nested list. Note that flatten() considers strings
+ to be scalars instead of sequences like Python would.
+ """
+ if isinstance(obj, StringTypes) or not isinstance(obj, SequenceTypes):
+ return [obj]
+ result = []
+ for item in obj:
+ if isinstance(item, StringTypes) or not isinstance(item, SequenceTypes):
+ result.append(item)
+ else:
+ do_flatten(item, result)
+ return result
+
+ def flatten_sequence(sequence, isinstance=isinstance, StringTypes=StringTypes,
+ SequenceTypes=SequenceTypes, do_flatten=do_flatten):
+ """Flatten a sequence to a non-nested list.
+
+ Same as flatten(), but it does not handle the single scalar
+ case. This is slightly more efficient when one knows that
+ the sequence to flatten can not be a scalar.
+ """
+ result = []
+ for item in sequence:
+ if isinstance(item, StringTypes) or not isinstance(item, SequenceTypes):
+ result.append(item)
+ else:
+ do_flatten(item, result)
+ return result
+
+
+ #
+ # Generic convert-to-string functions that abstract away whether or
+ # not the Python we're executing has Unicode support. The wrapper
+ # to_String_for_signature() will use a for_signature() method if the
+ # specified object has one.
+ #
+ def to_String(s,
+ isinstance=isinstance, str=str,
+ UserString=UserString, BaseStringTypes=BaseStringTypes):
+ if isinstance(s,BaseStringTypes):
+ # Early out when already a string!
+ return s
+ elif isinstance(s, UserString):
+ # s.data can only be either a unicode or a regular
+ # string. Please see the UserString initializer.
+ return s.data
+ else:
+ return str(s)
+
+ def to_String_for_subst(s,
+ isinstance=isinstance, str=str, to_String=to_String,
+ BaseStringTypes=BaseStringTypes, SequenceTypes=SequenceTypes,
+ UserString=UserString):
+
+ # Note that the test cases are sorted by order of probability.
+ if isinstance(s, BaseStringTypes):
+ return s
+ elif isinstance(s, SequenceTypes):
+ l = []
+ for e in s:
+ l.append(to_String_for_subst(e))
+ return ' '.join( s )
+ elif isinstance(s, UserString):
+ # s.data can only be either a unicode or a regular
+ # string. Please see the UserString initializer.
+ return s.data
+ else:
+ return str(s)
+
+ def to_String_for_signature(obj, to_String_for_subst=to_String_for_subst,
+ AttributeError=AttributeError):
+ try:
+ f = obj.for_signature
+ except AttributeError:
+ return to_String_for_subst(obj)
+ else:
+ return f()
+
+
+
+# The SCons "semi-deep" copy.
+#
+# This makes separate copies of lists (including UserList objects)
+# dictionaries (including UserDict objects) and tuples, but just copies
+# references to anything else it finds.
+#
+# A special case is any object that has a __semi_deepcopy__() method,
+# which we invoke to create the copy, which is used by the BuilderDict
+# class because of its extra initialization argument.
+#
+# The dispatch table approach used here is a direct rip-off from the
+# normal Python copy module.
+
+_semi_deepcopy_dispatch = d = {}
+
+def _semi_deepcopy_dict(x):
+ copy = {}
+ for key, val in x.items():
+ # The regular Python copy.deepcopy() also deepcopies the key,
+ # as follows:
+ #
+ # copy[semi_deepcopy(key)] = semi_deepcopy(val)
+ #
+ # Doesn't seem like we need to, but we'll comment it just in case.
+ copy[key] = semi_deepcopy(val)
+ return copy
+d[dict] = _semi_deepcopy_dict
+
+def _semi_deepcopy_list(x):
+ return list(map(semi_deepcopy, x))
+d[list] = _semi_deepcopy_list
+
+def _semi_deepcopy_tuple(x):
+ return tuple(map(semi_deepcopy, x))
+d[tuple] = _semi_deepcopy_tuple
+
+def _semi_deepcopy_inst(x):
+ if hasattr(x, '__semi_deepcopy__'):
+ return x.__semi_deepcopy__()
+ elif isinstance(x, UserDict):
+ return x.__class__(_semi_deepcopy_dict(x))
+ elif isinstance(x, UserList):
+ return x.__class__(_semi_deepcopy_list(x))
+ else:
+ return x
+d[types.InstanceType] = _semi_deepcopy_inst
+
+def semi_deepcopy(x):
+ copier = _semi_deepcopy_dispatch.get(type(x))
+ if copier:
+ return copier(x)
+ else:
+ return x
+
+
class Proxy:
"""A simple generic Proxy class, forwarding all calls to
- subject. Inherit from this class to create a Proxy."""
+ subject. So, for the benefit of the python newbie, what does
+ this really mean? Well, it means that you can take an object, let's
+ call it 'objA', and wrap it in this Proxy class, with a statement
+ like this
+
+ proxyObj = Proxy(objA),
+
+ Then, if in the future, you do something like this
+
+ x = proxyObj.var1,
+
+ since Proxy does not have a 'var1' attribute (but presumably objA does),
+ the request actually is equivalent to saying
+
+ x = objA.var1
+
+ Inherit from this class to create a Proxy."""
+
def __init__(self, subject):
+ """Wrap an object as a Proxy object"""
self.__subject = subject
-
+
def __getattr__(self, name):
+ """Retrieve an attribute from the wrapped object. If the named
+ attribute doesn't exist, AttributeError is raised"""
return getattr(self.__subject, name)
def get(self):
+ """Retrieve the entire wrapped object"""
return self.__subject
+ def __cmp__(self, other):
+ if issubclass(other.__class__, self.__subject.__class__):
+ return cmp(self.__subject, other)
+ return cmp(self.__dict__, other.__dict__)
+
# attempt to load the windows registry module:
can_read_reg = 0
try:
can_read_reg = 1
hkey_mod = _winreg
- RegOpenKeyEx = _winreg.OpenKeyEx
- RegEnumKey = _winreg.EnumKey
- RegEnumValue = _winreg.EnumValue
+ RegOpenKeyEx = _winreg.OpenKeyEx
+ RegEnumKey = _winreg.EnumKey
+ RegEnumValue = _winreg.EnumValue
RegQueryValueEx = _winreg.QueryValueEx
- RegError = _winreg.error
+ RegError = _winreg.error
except ImportError:
try:
can_read_reg = 1
hkey_mod = win32con
- RegOpenKeyEx = win32api.RegOpenKeyEx
- RegEnumKey = win32api.RegEnumKey
- RegEnumValue = win32api.RegEnumValue
+ RegOpenKeyEx = win32api.RegOpenKeyEx
+ RegEnumKey = win32api.RegEnumKey
+ RegEnumValue = win32api.RegEnumValue
RegQueryValueEx = win32api.RegQueryValueEx
- RegError = win32api.error
+ RegError = win32api.error
except ImportError:
class _NoError(Exception):
RegError = _NoError
if can_read_reg:
- HKEY_CLASSES_ROOT = hkey_mod.HKEY_CLASSES_ROOT
+ HKEY_CLASSES_ROOT = hkey_mod.HKEY_CLASSES_ROOT
HKEY_LOCAL_MACHINE = hkey_mod.HKEY_LOCAL_MACHINE
- HKEY_CURRENT_USER = hkey_mod.HKEY_CURRENT_USER
- HKEY_USERS = hkey_mod.HKEY_USERS
+ HKEY_CURRENT_USER = hkey_mod.HKEY_CURRENT_USER
+ HKEY_USERS = hkey_mod.HKEY_USERS
def RegGetValue(root, key):
"""This utility function returns a value in the registry
# I would use os.path.split here, but it's not a filesystem
# path...
p = key.rfind('\\') + 1
- keyp = key[:p]
+ keyp = key[:p-1] # -1 to omit trailing slash
val = key[p:]
- k = SCons.Util.RegOpenKeyEx(root, keyp)
- return SCons.Util.RegQueryValueEx(k,val)
+ k = RegOpenKeyEx(root, keyp)
+ return RegQueryValueEx(k,val)
+else:
+ try:
+ e = WindowsError
+ except NameError:
+ # Make sure we have a definition of WindowsError so we can
+ # run platform-independent tests of Windows functionality on
+ # platforms other than Windows. (WindowsError is, in fact, an
+ # OSError subclass on Windows.)
+ class WindowsError(OSError):
+ pass
+ import __builtin__
+ __builtin__.WindowsError = WindowsError
+ else:
+ del e
+
+ HKEY_CLASSES_ROOT = None
+ HKEY_LOCAL_MACHINE = None
+ HKEY_CURRENT_USER = None
+ HKEY_USERS = None
+
+ def RegGetValue(root, key):
+ raise WindowsError
+
+ def RegOpenKeyEx(root, key):
+ raise WindowsError
if sys.platform == 'win32':
- def WhereIs(file, path=None, pathext=None):
+ def WhereIs(file, path=None, pathext=None, reject=[]):
if path is None:
- path = os.environ['PATH']
+ try:
+ path = os.environ['PATH']
+ except KeyError:
+ return None
if is_String(path):
- path = string.split(path, os.pathsep)
+ path = path.split(os.pathsep)
if pathext is None:
try:
pathext = os.environ['PATHEXT']
except KeyError:
pathext = '.COM;.EXE;.BAT;.CMD'
if is_String(pathext):
- pathext = string.split(pathext, os.pathsep)
+ pathext = pathext.split(os.pathsep)
for ext in pathext:
- if string.lower(ext) == string.lower(file[-len(ext):]):
+ if ext.lower() == file[-len(ext):].lower():
pathext = ['']
break
+ if not is_List(reject) and not is_Tuple(reject):
+ reject = [reject]
for dir in path:
f = os.path.join(dir, file)
for ext in pathext:
fext = f + ext
if os.path.isfile(fext):
- return os.path.normpath(fext)
+ try:
+ reject.index(fext)
+ except ValueError:
+ return os.path.normpath(fext)
+ continue
return None
elif os.name == 'os2':
- def WhereIs(file, path=None, pathext=None):
+ def WhereIs(file, path=None, pathext=None, reject=[]):
if path is None:
- path = os.environ['PATH']
+ try:
+ path = os.environ['PATH']
+ except KeyError:
+ return None
if is_String(path):
- path = string.split(path, os.pathsep)
+ path = path.split(os.pathsep)
if pathext is None:
pathext = ['.exe', '.cmd']
for ext in pathext:
- if string.lower(ext) == string.lower(file[-len(ext):]):
+ if ext.lower() == file[-len(ext):].lower():
pathext = ['']
break
+ if not is_List(reject) and not is_Tuple(reject):
+ reject = [reject]
for dir in path:
f = os.path.join(dir, file)
for ext in pathext:
fext = f + ext
if os.path.isfile(fext):
- return os.path.normpath(fext)
+ try:
+ reject.index(fext)
+ except ValueError:
+ return os.path.normpath(fext)
+ continue
return None
else:
- def WhereIs(file, path=None, pathext=None):
+ def WhereIs(file, path=None, pathext=None, reject=[]):
+ import stat
if path is None:
- path = os.environ['PATH']
+ try:
+ path = os.environ['PATH']
+ except KeyError:
+ return None
if is_String(path):
- path = string.split(path, os.pathsep)
- for dir in path:
- f = os.path.join(dir, file)
+ path = path.split(os.pathsep)
+ if not is_List(reject) and not is_Tuple(reject):
+ reject = [reject]
+ for d in path:
+ f = os.path.join(d, file)
if os.path.isfile(f):
try:
st = os.stat(f)
- except:
+ except OSError:
+ # os.stat() raises OSError, not IOError if the file
+ # doesn't exist, so in this case we let IOError get
+ # raised so as to not mask possibly serious disk or
+ # network issues.
continue
if stat.S_IMODE(st[stat.ST_MODE]) & 0111:
- return os.path.normpath(f)
+ try:
+ reject.index(f)
+ except ValueError:
+ return os.path.normpath(f)
+ continue
return None
-def PrependPath(oldpath, newpath, sep = os.pathsep):
+def PrependPath(oldpath, newpath, sep = os.pathsep,
+ delete_existing=1, canonicalize=None):
"""This prepends newpath elements to the given oldpath. Will only
add any particular path once (leaving the first one it encounters
and ignoring the rest, to preserve path order), and will
Old Path: "/foo/bar:/foo"
New Path: "/biz/boom:/foo"
Result: "/biz/boom:/foo:/foo/bar"
+
+ If delete_existing is 0, then adding a path that exists will
+ not move it to the beginning; it will stay where it is in the
+ list.
+
+ If canonicalize is not None, it is applied to each element of
+ newpath before use.
"""
orig = oldpath
is_list = 1
paths = orig
- if not SCons.Util.is_List(orig):
- paths = string.split(paths, sep)
+ if not is_List(orig) and not is_Tuple(orig):
+ paths = paths.split(sep)
is_list = 0
- if SCons.Util.is_List(newpath):
- newpaths = newpath
+ if is_String(newpath):
+ newpaths = newpath.split(sep)
+ elif not is_List(newpath) and not is_Tuple(newpath):
+ newpaths = [ newpath ] # might be a Dir
else:
- newpaths = string.split(newpath, sep)
+ newpaths = newpath
- newpaths = newpaths + paths # prepend new paths
+ if canonicalize:
+ newpaths=list(map(canonicalize, newpaths))
+
+ if not delete_existing:
+ # First uniquify the old paths, making sure to
+ # preserve the first instance (in Unix/Linux,
+ # the first one wins), and remembering them in normpaths.
+ # Then insert the new paths at the head of the list
+ # if they're not already in the normpaths list.
+ result = []
+ normpaths = []
+ for path in paths:
+ if not path:
+ continue
+ normpath = os.path.normpath(os.path.normcase(path))
+ if normpath not in normpaths:
+ result.append(path)
+ normpaths.append(normpath)
+ newpaths.reverse() # since we're inserting at the head
+ for path in newpaths:
+ if not path:
+ continue
+ normpath = os.path.normpath(os.path.normcase(path))
+ if normpath not in normpaths:
+ result.insert(0, path)
+ normpaths.append(normpath)
+ paths = result
- normpaths = []
- paths = []
- # now we add them only of they are unique
- for path in newpaths:
- normpath = os.path.normpath(os.path.normcase(path))
- if path and not normpath in normpaths:
- paths.append(path)
- normpaths.append(normpath)
+ else:
+ newpaths = newpaths + paths # prepend new paths
+
+ normpaths = []
+ paths = []
+ # now we add them only if they are unique
+ for path in newpaths:
+ normpath = os.path.normpath(os.path.normcase(path))
+ if path and not normpath in normpaths:
+ paths.append(path)
+ normpaths.append(normpath)
if is_list:
return paths
else:
- return string.join(paths, sep)
+ return sep.join(paths)
-def AppendPath(oldpath, newpath, sep = os.pathsep):
+def AppendPath(oldpath, newpath, sep = os.pathsep,
+ delete_existing=1, canonicalize=None):
"""This appends new path elements to the given old path. Will
only add any particular path once (leaving the last one it
encounters and ignoring the rest, to preserve path order), and
Old Path: "/foo/bar:/foo"
New Path: "/biz/boom:/foo"
Result: "/foo/bar:/biz/boom:/foo"
+
+ If delete_existing is 0, then adding a path that exists
+ will not move it to the end; it will stay where it is in the list.
+
+ If canonicalize is not None, it is applied to each element of
+ newpath before use.
"""
orig = oldpath
is_list = 1
paths = orig
- if not SCons.Util.is_List(orig):
- paths = string.split(paths, sep)
+ if not is_List(orig) and not is_Tuple(orig):
+ paths = paths.split(sep)
is_list = 0
- if SCons.Util.is_List(newpath):
+ if is_String(newpath):
+ newpaths = newpath.split(sep)
+ elif not is_List(newpath) and not is_Tuple(newpath):
+ newpaths = [ newpath ] # might be a Dir
+ else:
newpaths = newpath
+
+ if canonicalize:
+ newpaths=list(map(canonicalize, newpaths))
+
+ if not delete_existing:
+ # add old paths to result, then
+ # add new paths if not already present
+ # (I thought about using a dict for normpaths for speed,
+ # but it's not clear hashing the strings would be faster
+ # than linear searching these typically short lists.)
+ result = []
+ normpaths = []
+ for path in paths:
+ if not path:
+ continue
+ result.append(path)
+ normpaths.append(os.path.normpath(os.path.normcase(path)))
+ for path in newpaths:
+ if not path:
+ continue
+ normpath = os.path.normpath(os.path.normcase(path))
+ if normpath not in normpaths:
+ result.append(path)
+ normpaths.append(normpath)
+ paths = result
else:
- newpaths = string.split(newpath, sep)
-
- newpaths = paths + newpaths # append new paths
- newpaths.reverse()
-
- normpaths = []
- paths = []
- # now we add them only of they are unique
- for path in newpaths:
- normpath = os.path.normpath(os.path.normcase(path))
- if path and not normpath in normpaths:
- paths.append(path)
- normpaths.append(normpath)
-
- paths.reverse()
+ # start w/ new paths, add old ones if not present,
+ # then reverse.
+ newpaths = paths + newpaths # append new paths
+ newpaths.reverse()
+
+ normpaths = []
+ paths = []
+ # now we add them only if they are unique
+ for path in newpaths:
+ normpath = os.path.normpath(os.path.normcase(path))
+ if path and not normpath in normpaths:
+ paths.append(path)
+ normpaths.append(normpath)
+ paths.reverse()
if is_list:
return paths
else:
- return string.join(paths, sep)
-
-
-def ParseConfig(env, command, function=None):
- """Use the specified function to parse the output of the command in order
- to modify the specified environment. The 'command' can be a string or a
- list of strings representing a command and it's arguments. 'Function' is
- an optional argument that takes the environment and the output of the
- command. If no function is specified, the output will be treated as the
- output of a typical 'X-config' command (i.e. gtk-config) and used to set
- the CPPPATH, LIBPATH, LIBS, and CCFLAGS variables.
- """
- # the default parse function
- def parse_conf(env, output):
- env_dict = env.Dictionary()
- static_libs = []
-
- # setup all the dictionary options
- if not env_dict.has_key('CPPPATH'):
- env_dict['CPPPATH'] = []
- if not env_dict.has_key('LIBPATH'):
- env_dict['LIBPATH'] = []
- if not env_dict.has_key('LIBS'):
- env_dict['LIBS'] = []
- if not env_dict.has_key('CCFLAGS') or env_dict['CCFLAGS'] == "":
- env_dict['CCFLAGS'] = []
-
- params = string.split(output)
- for arg in params:
- switch = arg[0:1]
- opt = arg[1:2]
- if switch == '-':
- if opt == 'L':
- env_dict['LIBPATH'].append(arg[2:])
- elif opt == 'l':
- env_dict['LIBS'].append(arg[2:])
- elif opt == 'I':
- env_dict['CPPPATH'].append(arg[2:])
- else:
- env_dict['CCFLAGS'].append(arg)
- else:
- static_libs.append(arg)
- return static_libs
-
- if function is None:
- function = parse_conf
- if type(command) is type([]):
- command = string.join(command)
- return function(env, os.popen(command).read())
-
-def dir_index(directory):
- files = []
- for file in os.listdir(directory):
- fullname = os.path.join(directory, file)
- files.append(fullname)
-
- # os.listdir() isn't guaranteed to return files in any specific order,
- # but some of the test code expects sorted output.
- files.sort()
- return files
-
-def fs_delete(path, remove=1):
- try:
- if os.path.exists(path):
- if os.path.isfile(path):
- if remove: os.unlink(path)
- display("Removed " + path)
- elif os.path.isdir(path) and not os.path.islink(path):
- # delete everything in the dir
- for p in dir_index(path):
- if os.path.isfile(p):
- if remove: os.unlink(p)
- display("Removed " + p)
- else:
- fs_delete(p, remove)
- # then delete dir itself
- if remove: os.rmdir(path)
- display("Removed directory " + path)
- except OSError, e:
- print "scons: Could not remove '%s':" % str(path), e.strerror
+ return sep.join(paths)
if sys.platform == 'cygwin':
def get_native_path(path):
"""Transforms an absolute path into a native path for the system. In
- Cygwin, this converts from a Cygwin path to a Win32 one."""
- return string.replace(os.popen('cygpath -w ' + path).read(), '\n', '')
+ Cygwin, this converts from a Cygwin path to a Windows one."""
+ return os.popen('cygpath -w ' + path).read().replace('\n', '')
else:
def get_native_path(path):
"""Transforms an absolute path into a native path for the system.
return path
display = DisplayEngine()
+
+def Split(arg):
+ if is_List(arg) or is_Tuple(arg):
+ return arg
+ elif is_String(arg):
+ return arg.split()
+ else:
+ return [arg]
+
+class CLVar(UserList):
+ """A class for command-line construction variables.
+
+ This is a list that uses Split() to split an initial string along
+ white-space arguments, and similarly to split any strings that get
+ added. This allows us to Do the Right Thing with Append() and
+ Prepend() (as well as straight Python foo = env['VAR'] + 'arg1
+ arg2') regardless of whether a user adds a list or a string to a
+ command-line construction variable.
+ """
+ def __init__(self, seq = []):
+ UserList.__init__(self, Split(seq))
+ def __add__(self, other):
+ return UserList.__add__(self, CLVar(other))
+ def __radd__(self, other):
+ return UserList.__radd__(self, CLVar(other))
+ def __coerce__(self, other):
+ return (self, CLVar(other))
+ def __str__(self):
+ return ' '.join(self.data)
+
+# A dictionary that preserves the order in which items are added.
+# Submitted by David Benjamin to ActiveState's Python Cookbook web site:
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/107747
+# Including fixes/enhancements from the follow-on discussions.
+class OrderedDict(UserDict):
+ def __init__(self, dict = None):
+ self._keys = []
+ UserDict.__init__(self, dict)
+
+ def __delitem__(self, key):
+ UserDict.__delitem__(self, key)
+ self._keys.remove(key)
+
+ def __setitem__(self, key, item):
+ UserDict.__setitem__(self, key, item)
+ if key not in self._keys: self._keys.append(key)
+
+ def clear(self):
+ UserDict.clear(self)
+ self._keys = []
+
+ def copy(self):
+ dict = OrderedDict()
+ dict.update(self)
+ return dict
+
+ def items(self):
+ return list(zip(self._keys, self.values()))
+
+ def keys(self):
+ return self._keys[:]
+
+ def popitem(self):
+ try:
+ key = self._keys[-1]
+ except IndexError:
+ raise KeyError('dictionary is empty')
+
+ val = self[key]
+ del self[key]
+
+ return (key, val)
+
+ def setdefault(self, key, failobj = None):
+ UserDict.setdefault(self, key, failobj)
+ if key not in self._keys: self._keys.append(key)
+
+ def update(self, dict):
+ for (key, val) in dict.items():
+ self.__setitem__(key, val)
+
+ def values(self):
+ return list(map(self.get, self._keys))
+
+class Selector(OrderedDict):
+ """A callable ordered dictionary that maps file suffixes to
+ dictionary values. We preserve the order in which items are added
+ so that get_suffix() calls always return the first suffix added."""
+ def __call__(self, env, source, ext=None):
+ if ext is None:
+ try:
+ ext = source[0].suffix
+ except IndexError:
+ ext = ""
+ try:
+ return self[ext]
+ except KeyError:
+ # Try to perform Environment substitution on the keys of
+ # the dictionary before giving up.
+ s_dict = {}
+ for (k,v) in self.items():
+ if k is not None:
+ s_k = env.subst(k)
+ if s_k in s_dict:
+ # We only raise an error when variables point
+ # to the same suffix. If one suffix is literal
+ # and a variable suffix contains this literal,
+ # the literal wins and we don't raise an error.
+ raise KeyError, (s_dict[s_k][0], k, s_k)
+ s_dict[s_k] = (k,v)
+ try:
+ return s_dict[ext][1]
+ except KeyError:
+ try:
+ return self[None]
+ except KeyError:
+ return None
+
+
+if sys.platform == 'cygwin':
+ # On Cygwin, os.path.normcase() lies, so just report back the
+ # fact that the underlying Windows OS is case-insensitive.
+ def case_sensitive_suffixes(s1, s2):
+ return 0
+else:
+ def case_sensitive_suffixes(s1, s2):
+ return (os.path.normcase(s1) != os.path.normcase(s2))
+
+def adjustixes(fname, pre, suf, ensure_suffix=False):
+ if pre:
+ path, fn = os.path.split(os.path.normpath(fname))
+ if fn[:len(pre)] != pre:
+ fname = os.path.join(path, pre + fn)
+ # Only append a suffix if the suffix we're going to add isn't already
+ # there, and if either we've been asked to ensure the specific suffix
+ # is present or there's no suffix on it at all.
+ if suf and fname[-len(suf):] != suf and \
+ (ensure_suffix or not splitext(fname)[1]):
+ fname = fname + suf
+ return fname
+
+
+
+# From Tim Peters,
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52560
+# ASPN: Python Cookbook: Remove duplicates from a sequence
+# (Also in the printed Python Cookbook.)
+
+def unique(s):
+ """Return a list of the elements in s, but without duplicates.
+
+ For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
+ unique("abcabc") some permutation of ["a", "b", "c"], and
+ unique(([1, 2], [2, 3], [1, 2])) some permutation of
+ [[2, 3], [1, 2]].
+
+ For best speed, all sequence elements should be hashable. Then
+ unique() will usually work in linear time.
+
+ If not possible, the sequence elements should enjoy a total
+ ordering, and if list(s).sort() doesn't raise TypeError it's
+ assumed that they do enjoy a total ordering. Then unique() will
+ usually work in O(N*log2(N)) time.
+
+ If that's not possible either, the sequence elements must support
+ equality-testing. Then unique() will usually work in quadratic
+ time.
+ """
+
+ n = len(s)
+ if n == 0:
+ return []
+
+ # Try using a dict first, as that's the fastest and will usually
+ # work. If it doesn't work, it will usually fail quickly, so it
+ # usually doesn't cost much to *try* it. It requires that all the
+ # sequence elements be hashable, and support equality comparison.
+ u = {}
+ try:
+ for x in s:
+ u[x] = 1
+ except TypeError:
+ pass # move on to the next method
+ else:
+ return u.keys()
+ del u
+
+ # We can't hash all the elements. Second fastest is to sort,
+ # which brings the equal elements together; then duplicates are
+ # easy to weed out in a single pass.
+ # NOTE: Python's list.sort() was designed to be efficient in the
+ # presence of many duplicate elements. This isn't true of all
+ # sort functions in all languages or libraries, so this approach
+ # is more effective in Python than it may be elsewhere.
+ try:
+ t = sorted(s)
+ except TypeError:
+ pass # move on to the next method
+ else:
+ assert n > 0
+ last = t[0]
+ lasti = i = 1
+ while i < n:
+ if t[i] != last:
+ t[lasti] = last = t[i]
+ lasti = lasti + 1
+ i = i + 1
+ return t[:lasti]
+ del t
+
+ # Brute force is all that's left.
+ u = []
+ for x in s:
+ if x not in u:
+ u.append(x)
+ return u
+
+
+
+# From Alex Martelli,
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52560
+# ASPN: Python Cookbook: Remove duplicates from a sequence
+# First comment, dated 2001/10/13.
+# (Also in the printed Python Cookbook.)
+
+def uniquer(seq, idfun=None):
+ if idfun is None:
+ def idfun(x): return x
+ seen = {}
+ result = []
+ for item in seq:
+ marker = idfun(item)
+ # in old Python versions:
+ # if seen.has_key(marker)
+ # but in new ones:
+ if marker in seen: continue
+ seen[marker] = 1
+ result.append(item)
+ return result
+
+# A more efficient implementation of Alex's uniquer(), this avoids the
+# idfun() argument and function-call overhead by assuming that all
+# items in the sequence are hashable.
+
+def uniquer_hashables(seq):
+ seen = {}
+ result = []
+ for item in seq:
+ #if not item in seen:
+ if item not in seen:
+ seen[item] = 1
+ result.append(item)
+ return result
+
+
+
+# Much of the logic here was originally based on recipe 4.9 from the
+# Python CookBook, but we had to dumb it way down for Python 1.5.2.
+class LogicalLines:
+
+ def __init__(self, fileobj):
+ self.fileobj = fileobj
+
+ def readline(self):
+ result = []
+ while True:
+ line = self.fileobj.readline()
+ if not line:
+ break
+ if line[-2:] == '\\\n':
+ result.append(line[:-2])
+ else:
+ result.append(line)
+ break
+ return ''.join(result)
+
+ def readlines(self):
+ result = []
+ while True:
+ line = self.readline()
+ if not line:
+ break
+ result.append(line)
+ return result
+
+
+
+class UniqueList(UserList):
+ def __init__(self, seq = []):
+ UserList.__init__(self, seq)
+ self.unique = True
+ def __make_unique(self):
+ if not self.unique:
+ self.data = uniquer_hashables(self.data)
+ self.unique = True
+ def __lt__(self, other):
+ self.__make_unique()
+ return UserList.__lt__(self, other)
+ def __le__(self, other):
+ self.__make_unique()
+ return UserList.__le__(self, other)
+ def __eq__(self, other):
+ self.__make_unique()
+ return UserList.__eq__(self, other)
+ def __ne__(self, other):
+ self.__make_unique()
+ return UserList.__ne__(self, other)
+ def __gt__(self, other):
+ self.__make_unique()
+ return UserList.__gt__(self, other)
+ def __ge__(self, other):
+ self.__make_unique()
+ return UserList.__ge__(self, other)
+ def __cmp__(self, other):
+ self.__make_unique()
+ return UserList.__cmp__(self, other)
+ def __len__(self):
+ self.__make_unique()
+ return UserList.__len__(self)
+ def __getitem__(self, i):
+ self.__make_unique()
+ return UserList.__getitem__(self, i)
+ def __setitem__(self, i, item):
+ UserList.__setitem__(self, i, item)
+ self.unique = False
+ def __getslice__(self, i, j):
+ self.__make_unique()
+ return UserList.__getslice__(self, i, j)
+ def __setslice__(self, i, j, other):
+ UserList.__setslice__(self, i, j, other)
+ self.unique = False
+ def __add__(self, other):
+ result = UserList.__add__(self, other)
+ result.unique = False
+ return result
+ def __radd__(self, other):
+ result = UserList.__radd__(self, other)
+ result.unique = False
+ return result
+ def __iadd__(self, other):
+ result = UserList.__iadd__(self, other)
+ result.unique = False
+ return result
+ def __mul__(self, other):
+ result = UserList.__mul__(self, other)
+ result.unique = False
+ return result
+ def __rmul__(self, other):
+ result = UserList.__rmul__(self, other)
+ result.unique = False
+ return result
+ def __imul__(self, other):
+ result = UserList.__imul__(self, other)
+ result.unique = False
+ return result
+ def append(self, item):
+ UserList.append(self, item)
+ self.unique = False
+ def insert(self, i):
+ UserList.insert(self, i)
+ self.unique = False
+ def count(self, item):
+ self.__make_unique()
+ return UserList.count(self, item)
+ def index(self, item):
+ self.__make_unique()
+ return UserList.index(self, item)
+ def reverse(self):
+ self.__make_unique()
+ UserList.reverse(self)
+ def sort(self, *args, **kwds):
+ self.__make_unique()
+ return UserList.sort(self, *args, **kwds)
+ def extend(self, other):
+ UserList.extend(self, other)
+ self.unique = False
+
+
+
+class Unbuffered:
+ """
+ A proxy class that wraps a file object, flushing after every write,
+ and delegating everything else to the wrapped object.
+ """
+ def __init__(self, file):
+ self.file = file
+ def write(self, arg):
+ try:
+ self.file.write(arg)
+ self.file.flush()
+ except IOError:
+ # Stdout might be connected to a pipe that has been closed
+ # by now. The most likely reason for the pipe being closed
+ # is that the user has press ctrl-c. It this is the case,
+ # then SCons is currently shutdown. We therefore ignore
+ # IOError's here so that SCons can continue and shutdown
+ # properly so that the .sconsign is correctly written
+ # before SCons exits.
+ pass
+ def __getattr__(self, attr):
+ return getattr(self.file, attr)
+
+def make_path_relative(path):
+ """ makes an absolute path name to a relative pathname.
+ """
+ if os.path.isabs(path):
+ drive_s,path = os.path.splitdrive(path)
+
+ import re
+ if not drive_s:
+ path=re.compile("/*(.*)").findall(path)[0]
+ else:
+ path=path[1:]
+
+ assert( not os.path.isabs( path ) ), path
+ return path
+
+
+
+# The original idea for AddMethod() and RenameFunction() come from the
+# following post to the ActiveState Python Cookbook:
+#
+# ASPN: Python Cookbook : Install bound methods in an instance
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/223613
+#
+# That code was a little fragile, though, so the following changes
+# have been wrung on it:
+#
+# * Switched the installmethod() "object" and "function" arguments,
+# so the order reflects that the left-hand side is the thing being
+# "assigned to" and the right-hand side is the value being assigned.
+#
+# * Changed explicit type-checking to the "try: klass = object.__class__"
+# block in installmethod() below so that it still works with the
+# old-style classes that SCons uses.
+#
+# * Replaced the by-hand creation of methods and functions with use of
+# the "new" module, as alluded to in Alex Martelli's response to the
+# following Cookbook post:
+#
+# ASPN: Python Cookbook : Dynamically added methods to a class
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81732
+
+def AddMethod(object, function, name = None):
+ """
+ Adds either a bound method to an instance or an unbound method to
+ a class. If name is ommited the name of the specified function
+ is used by default.
+ Example:
+ a = A()
+ def f(self, x, y):
+ self.z = x + y
+ AddMethod(f, A, "add")
+ a.add(2, 4)
+ print a.z
+ AddMethod(lambda self, i: self.l[i], a, "listIndex")
+ print a.listIndex(5)
+ """
+ import new
+
+ if name is None:
+ name = function.func_name
+ else:
+ function = RenameFunction(function, name)
+
+ try:
+ klass = object.__class__
+ except AttributeError:
+ # "object" is really a class, so it gets an unbound method.
+ object.__dict__[name] = new.instancemethod(function, None, object)
+ else:
+ # "object" is really an instance, so it gets a bound method.
+ object.__dict__[name] = new.instancemethod(function, object, klass)
+
+def RenameFunction(function, name):
+ """
+ Returns a function identical to the specified function, but with
+ the specified name.
+ """
+ import new
+
+ # Compatibility for Python 1.5 and 2.1. Can be removed in favor of
+ # passing function.func_defaults directly to new.function() once
+ # we base on Python 2.2 or later.
+ func_defaults = function.func_defaults
+ if func_defaults is None:
+ func_defaults = ()
+
+ return new.function(function.func_code,
+ function.func_globals,
+ name,
+ func_defaults)
+
+
+md5 = False
+def MD5signature(s):
+ return str(s)
+
+def MD5filesignature(fname, chunksize=65536):
+ f = open(fname, "rb")
+ result = f.read()
+ f.close()
+ return result
+
+try:
+ import hashlib
+except ImportError:
+ pass
+else:
+ if hasattr(hashlib, 'md5'):
+ md5 = True
+ def MD5signature(s):
+ m = hashlib.md5()
+ m.update(str(s))
+ return m.hexdigest()
+
+ def MD5filesignature(fname, chunksize=65536):
+ m = hashlib.md5()
+ f = open(fname, "rb")
+ while True:
+ blck = f.read(chunksize)
+ if not blck:
+ break
+ m.update(str(blck))
+ f.close()
+ return m.hexdigest()
+
+def MD5collect(signatures):
+ """
+ Collects a list of signatures into an aggregate signature.
+
+ signatures - a list of signatures
+ returns - the aggregate signature
+ """
+ if len(signatures) == 1:
+ return signatures[0]
+ else:
+ return MD5signature(', '.join(signatures))
+
+
+
+# Wrap the intern() function so it doesn't throw exceptions if ineligible
+# arguments are passed. The intern() function was moved into the sys module in
+# Python 3.
+try:
+ intern
+except NameError:
+ from sys import intern
+
+def silent_intern(x):
+ """
+ Perform intern() on the passed argument and return the result.
+ If the input is ineligible (e.g. a unicode string) the original argument is
+ returned and no exception is thrown.
+ """
+ try:
+ return intern(x)
+ except TypeError:
+ return x
+
+
+
+# From Dinu C. Gherman,
+# Python Cookbook, second edition, recipe 6.17, p. 277.
+# Also:
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/68205
+# ASPN: Python Cookbook: Null Object Design Pattern
+
+# TODO(1.5):
+#class Null(object):
+class Null:
+ """ Null objects always and reliably "do nothing." """
+ def __new__(cls, *args, **kwargs):
+ if not '_inst' in vars(cls):
+ cls._inst = type.__new__(cls, *args, **kwargs)
+ return cls._inst
+ def __init__(self, *args, **kwargs):
+ pass
+ def __call__(self, *args, **kwargs):
+ return self
+ def __repr__(self):
+ return "Null(0x%08X)" % id(self)
+ def __nonzero__(self):
+ return False
+ def __getattr__(self, name):
+ return self
+ def __setattr__(self, name, value):
+ return self
+ def __delattr__(self, name):
+ return self
+
+class NullSeq(Null):
+ def __len__(self):
+ return 0
+ def __iter__(self):
+ return iter(())
+ def __getitem__(self, i):
+ return self
+ def __delitem__(self, i):
+ return self
+ def __setitem__(self, i, v):
+ return self
+
+
+del __revision__
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4:
projects / scons.git / blobdiff