FCL/interim/QEMU: comparison symbian-qemu-0.9.1-12/python-2.6.1/Lib/string.py

equal deleted inserted replaced

-:ffa851df0825
+:2fb8b9db1c86
+"""A collection of string operations (most are no longer used).
+Warning: most of the code you see here isn't normally used nowadays.
+Beginning with Python 1.6, many of these functions are implemented as
+methods on the standard string object. They used to be implemented by
+a built-in module called strop, but strop is now obsolete itself.
+Public module variables:
+whitespace -- a string containing all characters considered whitespace
+lowercase -- a string containing all characters considered lowercase letters
+uppercase -- a string containing all characters considered uppercase letters
+letters -- a string containing all characters considered letters
+digits -- a string containing all characters considered decimal digits
+hexdigits -- a string containing all characters considered hexadecimal digits
+octdigits -- a string containing all characters considered octal digits
+punctuation -- a string containing all characters considered punctuation
+printable -- a string containing all characters considered printable
+"""
+# Some strings for ctype-style character classification
+whitespace = ' \t\n\r\v\f'
+lowercase = 'abcdefghijklmnopqrstuvwxyz'
+uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+letters = lowercase + uppercase
+ascii_lowercase = lowercase
+ascii_uppercase = uppercase
+ascii_letters = ascii_lowercase + ascii_uppercase
+digits = '0123456789'
+hexdigits = digits + 'abcdef' + 'ABCDEF'
+octdigits = '01234567'
+punctuation = """!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
+printable = digits + letters + punctuation + whitespace
+# Case conversion helpers
+# Use str to convert Unicode literal in case of -U
+l = map(chr, xrange(256))
+_idmap = str('').join(l)
+del l
+# Functions which aren't available as string methods.
+# Capitalize the words in a string, e.g. " aBc  dEf " -> "Abc Def".
+def capwords(s, sep=None):
+"""capwords(s, [sep]) -> string
+Split the argument into words using split, capitalize each
+word using capitalize, and join the capitalized words using
+join. Note that this replaces runs of whitespace characters by
+a single space.
+"""
+return (sep or ' ').join([x.capitalize() for x in s.split(sep)])
+# Construct a translation string
+_idmapL = None
+def maketrans(fromstr, tostr):
+"""maketrans(frm, to) -> string
+Return a translation table (a string of 256 bytes long)
+suitable for use in string.translate.  The strings frm and to
+must be of the same length.
+"""
+if len(fromstr) != len(tostr):
+raise ValueError, "maketrans arguments must have same length"
+global _idmapL
+if not _idmapL:
+_idmapL = list(_idmap)
+L = _idmapL[:]
+fromstr = map(ord, fromstr)
+for i in range(len(fromstr)):
+L[fromstr[i]] = tostr[i]
+return ''.join(L)
+####################################################################
+import re as _re
+class _multimap:
+"""Helper class for combining multiple mappings.
+Used by .{safe_,}substitute() to combine the mapping and keyword
+arguments.
+"""
+def __init__(self, primary, secondary):
+self._primary = primary
+self._secondary = secondary
+def __getitem__(self, key):
+try:
+return self._primary[key]
+except KeyError:
+return self._secondary[key]
+class _TemplateMetaclass(type):
+pattern = r"""
+%(delim)s(?:
+(?P<escaped>%(delim)s) |   # Escape sequence of two delimiters
+(?P<named>%(id)s)      |   # delimiter and a Python identifier
+{(?P<braced>%(id)s)}   |   # delimiter and a braced identifier
+(?P<invalid>)              # Other ill-formed delimiter exprs
+)
+"""
+def __init__(cls, name, bases, dct):
+super(_TemplateMetaclass, cls).__init__(name, bases, dct)
+if 'pattern' in dct:
+pattern = cls.pattern
+else:
+pattern = _TemplateMetaclass.pattern % {
+'delim' : _re.escape(cls.delimiter),
+'id'    : cls.idpattern,
+}
+cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)
+class Template:
+"""A string class for supporting $-substitutions."""
+__metaclass__ = _TemplateMetaclass
+delimiter = '$'
+idpattern = r'[_a-z][_a-z0-9]*'
+def __init__(self, template):
+self.template = template
+# Search for $$, $identifier, ${identifier}, and any bare $'s
+def _invalid(self, mo):
+i = mo.start('invalid')
+lines = self.template[:i].splitlines(True)
+if not lines:
+colno = 1
+lineno = 1
+else:
+colno = i - len(''.join(lines[:-1]))
+lineno = len(lines)
+raise ValueError('Invalid placeholder in string: line %d, col %d' %
+(lineno, colno))
+def substitute(self, *args, **kws):
+if len(args) > 1:
+raise TypeError('Too many positional arguments')
+if not args:
+mapping = kws
+elif kws:
+mapping = _multimap(kws, args[0])
+else:
+mapping = args[0]
+# Helper function for .sub()
+def convert(mo):
+# Check the most common path first.
+named = mo.group('named') or mo.group('braced')
+if named is not None:
+val = mapping[named]
+# We use this idiom instead of str() because the latter will
+# fail if val is a Unicode containing non-ASCII characters.
+return '%s' % (val,)
+if mo.group('escaped') is not None:
+return self.delimiter
+if mo.group('invalid') is not None:
+self._invalid(mo)
+raise ValueError('Unrecognized named group in pattern',
+self.pattern)
+return self.pattern.sub(convert, self.template)
+def safe_substitute(self, *args, **kws):
+if len(args) > 1:
+raise TypeError('Too many positional arguments')
+if not args:
+mapping = kws
+elif kws:
+mapping = _multimap(kws, args[0])
+else:
+mapping = args[0]
+# Helper function for .sub()
+def convert(mo):
+named = mo.group('named')
+if named is not None:
+try:
+# We use this idiom instead of str() because the latter
+# will fail if val is a Unicode containing non-ASCII
+return '%s' % (mapping[named],)
+except KeyError:
+return self.delimiter + named
+braced = mo.group('braced')
+if braced is not None:
+try:
+return '%s' % (mapping[braced],)
+except KeyError:
+return self.delimiter + '{' + braced + '}'
+if mo.group('escaped') is not None:
+return self.delimiter
+if mo.group('invalid') is not None:
+return self.delimiter
+raise ValueError('Unrecognized named group in pattern',
+self.pattern)
+return self.pattern.sub(convert, self.template)
+####################################################################
+# NOTE: Everything below here is deprecated.  Use string methods instead.
+# This stuff will go away in Python 3.0.
+# Backward compatible names for exceptions
+index_error = ValueError
+atoi_error = ValueError
+atof_error = ValueError
+atol_error = ValueError
+# convert UPPER CASE letters to lower case
+def lower(s):
+"""lower(s) -> string
+Return a copy of the string s converted to lowercase.
+"""
+return s.lower()
+# Convert lower case letters to UPPER CASE
+def upper(s):
+"""upper(s) -> string
+Return a copy of the string s converted to uppercase.
+"""
+return s.upper()
+# Swap lower case letters and UPPER CASE
+def swapcase(s):
+"""swapcase(s) -> string
+Return a copy of the string s with upper case characters
+converted to lowercase and vice versa.
+"""
+return s.swapcase()
+# Strip leading and trailing tabs and spaces
+def strip(s, chars=None):
+"""strip(s [,chars]) -> string
+Return a copy of the string s with leading and trailing
+whitespace removed.
+If chars is given and not None, remove characters in chars instead.
+If chars is unicode, S will be converted to unicode before stripping.
+"""
+return s.strip(chars)
+# Strip leading tabs and spaces
+def lstrip(s, chars=None):
+"""lstrip(s [,chars]) -> string
+Return a copy of the string s with leading whitespace removed.
+If chars is given and not None, remove characters in chars instead.
+"""
+return s.lstrip(chars)
+# Strip trailing tabs and spaces
+def rstrip(s, chars=None):
+"""rstrip(s [,chars]) -> string
+Return a copy of the string s with trailing whitespace removed.
+If chars is given and not None, remove characters in chars instead.
+"""
+return s.rstrip(chars)
+# Split a string into a list of space/tab-separated words
+def split(s, sep=None, maxsplit=-1):
+"""split(s [,sep [,maxsplit]]) -> list of strings
+Return a list of the words in the string s, using sep as the
+delimiter string.  If maxsplit is given, splits at no more than
+maxsplit places (resulting in at most maxsplit+1 words).  If sep
+is not specified or is None, any whitespace string is a separator.
+(split and splitfields are synonymous)
+"""
+return s.split(sep, maxsplit)
+splitfields = split
+# Split a string into a list of space/tab-separated words
+def rsplit(s, sep=None, maxsplit=-1):
+"""rsplit(s [,sep [,maxsplit]]) -> list of strings
+Return a list of the words in the string s, using sep as the
+delimiter string, starting at the end of the string and working
+to the front.  If maxsplit is given, at most maxsplit splits are
+done. If sep is not specified or is None, any whitespace string
+is a separator.
+"""
+return s.rsplit(sep, maxsplit)
+# Join fields with optional separator
+def join(words, sep = ' '):
+"""join(list [,sep]) -> string
+Return a string composed of the words in list, with
+intervening occurrences of sep.  The default separator is a
+single space.
+(joinfields and join are synonymous)
+"""
+return sep.join(words)
+joinfields = join
+# Find substring, raise exception if not found
+def index(s, *args):
+"""index(s, sub [,start [,end]]) -> int
+Like find but raises ValueError when the substring is not found.
+"""
+return s.index(*args)
+# Find last substring, raise exception if not found
+def rindex(s, *args):
+"""rindex(s, sub [,start [,end]]) -> int
+Like rfind but raises ValueError when the substring is not found.
+"""
+return s.rindex(*args)
+# Count non-overlapping occurrences of substring
+def count(s, *args):
+"""count(s, sub[, start[,end]]) -> int
+Return the number of occurrences of substring sub in string
+s[start:end].  Optional arguments start and end are
+interpreted as in slice notation.
+"""
+return s.count(*args)
+# Find substring, return -1 if not found
+def find(s, *args):
+"""find(s, sub [,start [,end]]) -> in
+Return the lowest index in s where substring sub is found,
+such that sub is contained within s[start,end].  Optional
+arguments start and end are interpreted as in slice notation.
+Return -1 on failure.
+"""
+return s.find(*args)
+# Find last substring, return -1 if not found
+def rfind(s, *args):
+"""rfind(s, sub [,start [,end]]) -> int
+Return the highest index in s where substring sub is found,
+such that sub is contained within s[start,end].  Optional
+arguments start and end are interpreted as in slice notation.
+Return -1 on failure.
+"""
+return s.rfind(*args)
+# for a bit of speed
+_float = float
+_int = int
+_long = long
+# Convert string to float
+def atof(s):
+"""atof(s) -> float
+Return the floating point number represented by the string s.
+"""
+return _float(s)
+# Convert string to integer
+def atoi(s , base=10):
+"""atoi(s [,base]) -> int
+Return the integer represented by the string s in the given
+base, which defaults to 10.  The string s must consist of one
+or more digits, possibly preceded by a sign.  If base is 0, it
+is chosen from the leading characters of s, 0 for octal, 0x or
+0X for hexadecimal.  If base is 16, a preceding 0x or 0X is
+accepted.
+"""
+return _int(s, base)
+# Convert string to long integer
+def atol(s, base=10):
+"""atol(s [,base]) -> long
+Return the long integer represented by the string s in the
+given base, which defaults to 10.  The string s must consist
+of one or more digits, possibly preceded by a sign.  If base
+is 0, it is chosen from the leading characters of s, 0 for
+octal, 0x or 0X for hexadecimal.  If base is 16, a preceding
+0x or 0X is accepted.  A trailing L or l is not accepted,
+unless base is 0.
+"""
+return _long(s, base)
+# Left-justify a string
+def ljust(s, width, *args):
+"""ljust(s, width[, fillchar]) -> string
+Return a left-justified version of s, in a field of the
+specified width, padded with spaces as needed.  The string is
+never truncated.  If specified the fillchar is used instead of spaces.
+"""
+return s.ljust(width, *args)
+# Right-justify a string
+def rjust(s, width, *args):
+"""rjust(s, width[, fillchar]) -> string
+Return a right-justified version of s, in a field of the
+specified width, padded with spaces as needed.  The string is
+never truncated.  If specified the fillchar is used instead of spaces.
+"""
+return s.rjust(width, *args)
+# Center a string
+def center(s, width, *args):
+"""center(s, width[, fillchar]) -> string
+Return a center version of s, in a field of the specified
+width. padded with spaces as needed.  The string is never
+truncated.  If specified the fillchar is used instead of spaces.
+"""
+return s.center(width, *args)
+# Zero-fill a number, e.g., (12, 3) --> '012' and (-3, 3) --> '-03'
+# Decadent feature: the argument may be a string or a number
+# (Use of this is deprecated; it should be a string as with ljust c.s.)
+def zfill(x, width):
+"""zfill(x, width) -> string
+Pad a numeric string x with zeros on the left, to fill a field
+of the specified width.  The string x is never truncated.
+"""
+if not isinstance(x, basestring):
+x = repr(x)
+return x.zfill(width)
+# Expand tabs in a string.
+# Doesn't take non-printing chars into account, but does understand \n.
+def expandtabs(s, tabsize=8):
+"""expandtabs(s [,tabsize]) -> string
+Return a copy of the string s with all tab characters replaced
+by the appropriate number of spaces, depending on the current
+column, and the tabsize (default 8).
+"""
+return s.expandtabs(tabsize)
+# Character translation through look-up table.
+def translate(s, table, deletions=""):
+"""translate(s,table [,deletions]) -> string
+Return a copy of the string s, where all characters occurring
+in the optional argument deletions are removed, and the
+remaining characters have been mapped through the given
+translation table, which must be a string of length 256.  The
+deletions argument is not allowed for Unicode strings.
+"""
+if deletions or table is None:
+return s.translate(table, deletions)
+else:
+# Add s[:0] so that if s is Unicode and table is an 8-bit string,
+# table is converted to Unicode.  This means that table *cannot*
+# be a dictionary -- for that feature, use u.translate() directly.
+return s.translate(table + s[:0])
+# Capitalize a string, e.g. "aBc  dEf" -> "Abc  def".
+def capitalize(s):
+"""capitalize(s) -> string
+Return a copy of the string s with only its first character
+capitalized.
+"""
+return s.capitalize()
+# Substring replacement (global)
+def replace(s, old, new, maxsplit=-1):
+"""replace (str, old, new[, maxsplit]) -> string
+Return a copy of string str with all occurrences of substring
+old replaced by new. If the optional argument maxsplit is
+given, only the first maxsplit occurrences are replaced.
+"""
+return s.replace(old, new, maxsplit)
+# Try importing optional built-in module "strop" -- if it exists,
+# it redefines some string operations that are 100-1000 times faster.
+# It also defines values for whitespace, lowercase and uppercase
+# that match <ctype.h>'s definitions.
+try:
+from strop import maketrans, lowercase, uppercase, whitespace
+letters = lowercase + uppercase
+except ImportError:
+pass                                          # Use the original versions
+########################################################################
+# the Formatter class
+# see PEP 3101 for details and purpose of this class
+# The hard parts are reused from the C implementation.  They're
+# exposed here via the sys module.  sys was chosen because it's always
+# available and doesn't have to be dynamically loaded.
+# The overall parser is implemented in str._formatter_parser.
+# The field name parser is implemented in str._formatter_field_name_split
+class Formatter(object):
+def format(self, format_string, *args, **kwargs):
+return self.vformat(format_string, args, kwargs)
+def vformat(self, format_string, args, kwargs):
+used_args = set()
+result = self._vformat(format_string, args, kwargs, used_args, 2)
+self.check_unused_args(used_args, args, kwargs)
+return result
+def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):
+if recursion_depth < 0:
+raise ValueError('Max string recursion exceeded')
+result = []
+for literal_text, field_name, format_spec, conversion in \
+self.parse(format_string):
+# output the literal text
+if literal_text:
+result.append(literal_text)
+# if there's a field, output it
+if field_name is not None:
+# this is some markup, find the object and do
+#  the formatting
+# given the field_name, find the object it references
+#  and the argument it came from
+obj, arg_used = self.get_field(field_name, args, kwargs)
+used_args.add(arg_used)
+# do any conversion on the resulting object
+obj = self.convert_field(obj, conversion)
+# expand the format spec, if needed
+format_spec = self._vformat(format_spec, args, kwargs,
+used_args, recursion_depth-1)
+# format the object and append to the result
+result.append(self.format_field(obj, format_spec))
+return ''.join(result)
+def get_value(self, key, args, kwargs):
+if isinstance(key, (int, long)):
+return args[key]
+else:
+return kwargs[key]
+def check_unused_args(self, used_args, args, kwargs):
+pass
+def format_field(self, value, format_spec):
+return format(value, format_spec)
+def convert_field(self, value, conversion):
+# do any conversion on the resulting object
+if conversion == 'r':
+return repr(value)
+elif conversion == 's':
+return str(value)
+elif conversion is None:
+return value
+raise ValueError("Unknown converion specifier {0!s}".format(conversion))
+# returns an iterable that contains tuples of the form:
+# (literal_text, field_name, format_spec, conversion)
+# literal_text can be zero length
+# field_name can be None, in which case there's no
+#  object to format and output
+# if field_name is not None, it is looked up, formatted
+#  with format_spec and conversion and then used
+def parse(self, format_string):
+return format_string._formatter_parser()
+# given a field_name, find the object it references.
+#  field_name:   the field being looked up, e.g. "0.name"
+#                 or "lookup[3]"
+#  used_args:    a set of which args have been used
+#  args, kwargs: as passed in to vformat
+def get_field(self, field_name, args, kwargs):
+first, rest = field_name._formatter_field_name_split()
+obj = self.get_value(first, args, kwargs)
+# loop through the rest of the field_name, doing
+#  getattr or getitem as needed
+for is_attr, i in rest:
+if is_attr:
+obj = getattr(obj, i)
+else:
+obj = obj[i]
+return obj, first