Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / devtools / v8plus / lib / python2.4 / encodings / __init__.py

""" Standard "encodings" Package

   Standard Python encoding modules are stored in this package
   directory.

   Codec modules must have names corresponding to normalized encoding
   names as defined in the normalize_encoding() function below, e.g.
   'utf-8' must be implemented by the module 'utf_8.py'.

   Each codec module must export the following interface:

   * getregentry() -> (encoder, decoder, stream_reader, stream_writer)
   The getregentry() API must return callable objects which adhere to
   the Python Codec Interface Standard.

   In addition, a module may optionally also define the following
   APIs which are then used by the package's codec search function:

   * getaliases() -> sequence of encoding name strings to use as aliases

   Alias names returned by getaliases() must be normalized encoding
   names as defined by normalize_encoding().

Written by Marc-Andre Lemburg (mal@lemburg.com).

(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.

"""#"

import codecs, exceptions, types, aliases

_cache = {}
_unknown = '--unknown--'
_import_tail = ['*']
_norm_encoding_map = ('                                              . '
                     '0123456789       ABCDEFGHIJKLMNOPQRSTUVWXYZ     '
                     ' abcdefghijklmnopqrstuvwxyz                     '
                     '                                                '
                     '                                                '
                     '                ')
_aliases = aliases.aliases

class CodecRegistryError(exceptions.LookupError,
                        exceptions.SystemError):
   pass

def normalize_encoding(encoding):

   """ Normalize an encoding name.

       Normalization works as follows: all non-alphanumeric
       characters except the dot used for Python package names are
       collapsed and replaced with a single underscore, e.g. '  -;#'
       becomes '_'. Leading and trailing underscores are removed.

       Note that encoding names should be ASCII only; if they do use
       non-ASCII characters, these must be Latin-1 compatible.

   """
   # Make sure we have an 8-bit string, because .translate() works
   # differently for Unicode strings.
   if type(encoding) is types.UnicodeType:
       # Note that .encode('latin-1') does *not* use the codec
       # registry, so this call doesn't recurse. (See unicodeobject.c
       # PyUnicode_AsEncodedString() for details)
       encoding = encoding.encode('latin-1')
   return '_'.join(encoding.translate(_norm_encoding_map).split())

def search_function(encoding):

   # Cache lookup
   entry = _cache.get(encoding, _unknown)
   if entry is not _unknown:
       return entry

   # Import the module:
   #
   # First try to find an alias for the normalized encoding
   # name and lookup the module using the aliased name, then try to
   # lookup the module using the standard import scheme, i.e. first
   # try in the encodings package, then at top-level.
   #
   norm_encoding = normalize_encoding(encoding)
   aliased_encoding = _aliases.get(norm_encoding) or \
                      _aliases.get(norm_encoding.replace('.', '_'))
   if aliased_encoding is not None:
       modnames = [aliased_encoding,
                   norm_encoding]
   else:
       modnames = [norm_encoding]
   for modname in modnames:
       if not modname:
           continue
       try:
           mod = __import__(modname,
                            globals(), locals(), _import_tail)
       except ImportError:
           pass
       else:
           break
   else:
       mod = None

   try:
       getregentry = mod.getregentry
   except AttributeError:
       # Not a codec module
       mod = None

   if mod is None:
       # Cache misses
       _cache[encoding] = None
       return None

   # Now ask the module for the registry entry
   entry = tuple(getregentry())
   if len(entry) != 4:
       raise CodecRegistryError,\
             'module "%s" (%s) failed to register' % \
             (mod.__name__, mod.__file__)
   for obj in entry:
       if not callable(obj):
           raise CodecRegistryError,\
                 'incompatible codecs in module "%s" (%s)' % \
                 (mod.__name__, mod.__file__)

   # Cache the codec registry entry
   _cache[encoding] = entry

   # Register its aliases (without overwriting previously registered
   # aliases)
   try:
       codecaliases = mod.getaliases()
   except AttributeError:
       pass
   else:
       for alias in codecaliases:
           if not _aliases.has_key(alias):
               _aliases[alias] = modname

   # Return the registry entry
   return entry

# Register the search_function in the Python codec registry
codecs.register(search_function)