public code v1

plugins/Jython/Lib/xml/FtCore.py

@@ -0,0 +1,58 @@
+"""
+Contains various definitions common to modules acquired from 4Suite
+"""
+
+__all__ = ["FtException", "get_translator"]
+
+
+class FtException(Exception):
+    def __init__(self, errorCode, messages, args):
+        # By defining __str__, args will be available.  Otherwise
+        # the __init__ of Exception sets it to the passed in arguments.
+        self.params = args
+        self.errorCode = errorCode
+        self.message = messages[errorCode] % args
+        Exception.__init__(self, self.message, args)
+
+    def __str__(self):
+        return self.message
+
+
+# What follows is used to provide support for I18N in the rest of the
+# 4Suite-derived packages in PyXML.
+#
+# Each sub-package of the top-level "xml" package that contains 4Suite
+# code is really a separate text domain, but they're all called
+# '4Suite'.  For each domain, a translation object is provided using
+# message catalogs stored inside the package.  The code below defines
+# a get_translator() function that returns an appropriate gettext
+# function to be used as _() in the sub-package named by the
+# parameter.  This handles all the compatibility issues related to
+# Python versions (whether the gettext module can be found) and
+# whether the message catalogs can actually be found.
+
+def _(msg):
+    return msg
+
+try:
+    import gettext
+
+except (ImportError, IOError):
+    def get_translator(pkg):
+        return _
+
+else:
+    import os
+
+    _cache = {}
+    _top = os.path.dirname(os.path.abspath(__file__))
+
+    def get_translator(pkg):
+        if not _cache.has_key(pkg):
+            locale_dir = os.path.join(_top, pkg.replace(".", os.sep))
+            try:
+                f = gettext.translation('4Suite', locale_dir).gettext
+            except IOError:
+                f = _
+            _cache[pkg] = f
+        return _cache[pkg]

plugins/Jython/Lib/xml/Uri.py

@@ -0,0 +1,380 @@
+# pylint: disable-msg=C0103
+#
+# backported code from 4Suite with slight modifications, started from r1.89 of
+# Ft/Lib/Uri.py, by syt@logilab.fr on 2005-02-09
+#
+# part if not all of this code should probably move to urlparse (or be used
+# to fix some existant functions in this module)
+#
+#
+# Copyright 2004 Fourthought, Inc. (USA).
+# Detailed license and copyright information: http://4suite.org/COPYRIGHT
+# Project home, documentation, distributions: http://4suite.org/
+import os.path
+import sys
+import re
+import urlparse, urllib, urllib2
+
+def UnsplitUriRef(uriRefSeq):
+    """should replace urlparse.urlunsplit
+
+    Given a sequence as would be produced by SplitUriRef(), assembles and
+    returns a URI reference as a string.
+    """
+    if not isinstance(uriRefSeq, (tuple, list)):
+        raise TypeError("sequence expected, got %s" % type(uriRefSeq))
+    (scheme, authority, path, query, fragment) = uriRefSeq
+    uri = ''
+    if scheme is not None:
+        uri += scheme + ':'
+    if authority is not None:
+        uri += '//' + authority
+    uri += path
+    if query is not None:
+        uri += '?' + query
+    if fragment is not None:
+        uri += '#' + fragment
+    return uri
+
+SPLIT_URI_REF_PATTERN = re.compile(r"^(?:(?P<scheme>[^:/?#]+):)?(?://(?P<authority>[^/?#]*))?(?P<path>[^?#]*)(?:\?(?P<query>[^#]*))?(?:#(?P<fragment>.*))?$")
+
+def SplitUriRef(uriref):
+    """should replace urlparse.urlsplit
+
+    Given a valid URI reference as a string, returns a tuple representing the
+    generic URI components, as per RFC 2396 appendix B. The tuple's structure
+    is (scheme, authority, path, query, fragment).
+
+    All values will be strings (possibly empty) or None if undefined.
+
+    Note that per rfc3986, there is no distinction between a path and
+    an "opaque part", as there was in RFC 2396.
+    """
+    # the pattern will match every possible string, so it's safe to
+    # assume there's a groupdict method to call.
+    g = SPLIT_URI_REF_PATTERN.match(uriref).groupdict()
+    scheme      = g['scheme']
+    authority   = g['authority']
+    path        = g['path']
+    query       = g['query']
+    fragment    = g['fragment']
+    return (scheme, authority, path, query, fragment)
+
+
+def Absolutize(uriRef, baseUri):
+    """
+    Resolves a URI reference to absolute form, effecting the result of RFC
+    3986 section 5. The URI reference is considered to be relative to the
+    given base URI.
+
+    It is the caller's responsibility to ensure that the base URI matches
+    the absolute-URI syntax rule of RFC 3986, and that its path component
+    does not contain '.' or '..' segments if the scheme is hierarchical.
+    Unexpected results may occur otherwise.
+
+    This function only conducts a minimal sanity check in order to determine
+    if relative resolution is possible: it raises a UriException if the base
+    URI does not have a scheme component. While it is true that the base URI
+    is irrelevant if the URI reference has a scheme, an exception is raised
+    in order to signal that the given string does not even come close to
+    meeting the criteria to be usable as a base URI.
+
+    It is the caller's responsibility to make a determination of whether the
+    URI reference constitutes a "same-document reference", as defined in RFC
+    2396 or RFC 3986. As per the spec, dereferencing a same-document
+    reference "should not" involve retrieval of a new representation of the
+    referenced resource. Note that the two specs have different definitions
+    of same-document reference: RFC 2396 says it is *only* the cases where the
+    reference is the empty string, or "#" followed by a fragment; RFC 3986
+    requires making a comparison of the base URI to the absolute form of the
+    reference (as is returned by the spec), minus its fragment component,
+    if any.
+
+    This function is similar to urlparse.urljoin() and urllib.basejoin().
+    Those functions, however, are (as of Python 2.3) outdated, buggy, and/or
+    designed to produce results acceptable for use with other core Python
+    libraries, rather than being earnest implementations of the relevant
+    specs. Their problems are most noticeable in their handling of
+    same-document references and 'file:' URIs, both being situations that
+    come up far too often to consider the functions reliable enough for
+    general use.
+    """
+    # Reasons to avoid using urllib.basejoin() and urlparse.urljoin():
+    # - Both are partial implementations of long-obsolete specs.
+    # - Both accept relative URLs as the base, which no spec allows.
+    # - urllib.basejoin() mishandles the '' and '..' references.
+    # - If the base URL uses a non-hierarchical or relative path,
+    #    or if the URL scheme is unrecognized, the result is not
+    #    always as expected (partly due to issues in RFC 1808).
+    # - If the authority component of a 'file' URI is empty,
+    #    the authority component is removed altogether. If it was
+    #    not present, an empty authority component is in the result.
+    # - '.' and '..' segments are not always collapsed as well as they
+    #    should be (partly due to issues in RFC 1808).
+    # - Effective Python 2.4, urllib.basejoin() *is* urlparse.urljoin(),
+    #    but urlparse.urljoin() is still based on RFC 1808.
+
+    # This procedure is based on the pseudocode in RFC 3986 sec. 5.2.
+    #
+    # ensure base URI is absolute
+    if not baseUri:
+        raise ValueError('baseUri is required and must be a non empty string')
+    if not IsAbsolute(baseUri):
+        raise ValueError('%r is not an absolute URI' % baseUri)
+    # shortcut for the simplest same-document reference cases
+    if uriRef == '' or uriRef[0] == '#':
+        return baseUri.split('#')[0] + uriRef
+    # ensure a clean slate
+    tScheme = tAuth = tPath = tQuery = None
+    # parse the reference into its components
+    (rScheme, rAuth, rPath, rQuery, rFrag) = SplitUriRef(uriRef)
+    # if the reference is absolute, eliminate '.' and '..' path segments
+    # and skip to the end
+    if rScheme is not None:
+        tScheme = rScheme
+        tAuth = rAuth
+        tPath = RemoveDotSegments(rPath)
+        tQuery = rQuery
+    else:
+        # the base URI's scheme, and possibly more, will be inherited
+        (bScheme, bAuth, bPath, bQuery, bFrag) = SplitUriRef(baseUri)
+        # if the reference is a net-path, just eliminate '.' and '..' path
+        # segments; no other changes needed.
+        if rAuth is not None:
+            tAuth = rAuth
+            tPath = RemoveDotSegments(rPath)
+            tQuery = rQuery
+        # if it's not a net-path, we need to inherit pieces of the base URI
+        else:
+            # use base URI's path if the reference's path is empty
+            if not rPath:
+                tPath = bPath
+                # use the reference's query, if any, or else the base URI's,
+                tQuery = rQuery is not None and rQuery or bQuery
+            # the reference's path is not empty
+            else:
+                # just use the reference's path if it's absolute
+                if rPath[0] == '/':
+                    tPath = RemoveDotSegments(rPath)
+                # merge the reference's relative path with the base URI's path
+                else:
+                    if bAuth is not None and not bPath:
+                        tPath = '/' + rPath
+                    else:
+                        tPath = bPath[:bPath.rfind('/')+1] + rPath
+                    tPath = RemoveDotSegments(tPath)
+                # use the reference's query
+                tQuery = rQuery
+            # since the reference isn't a net-path,
+            # use the authority from the base URI
+            tAuth = bAuth
+        # inherit the scheme from the base URI
+        tScheme = bScheme
+    # always use the reference's fragment (but no need to define another var)
+    #tFrag = rFrag
+
+    # now compose the target URI (RFC 3986 sec. 5.3)
+    return UnsplitUriRef((tScheme, tAuth, tPath, tQuery, rFrag))
+
+
+REG_NAME_HOST_PATTERN = re.compile(r"^(?:(?:[0-9A-Za-z\-_\.!~*'();&=+$,]|(?:%[0-9A-Fa-f]{2}))*)$")
+
+def MakeUrllibSafe(uriRef):
+    """
+    Makes the given RFC 3986-conformant URI reference safe for passing
+    to legacy urllib functions. The result may not be a valid URI.
+
+    As of Python 2.3.3, urllib.urlopen() does not fully support
+    internationalized domain names, it does not strip fragment components,
+    and on Windows, it expects file URIs to use '|' instead of ':' in the
+    path component corresponding to the drivespec. It also relies on
+    urllib.unquote(), which mishandles unicode arguments. This function
+    produces a URI reference that will work around these issues, although
+    the IDN workaround is limited to Python 2.3 only. May raise a
+    UnicodeEncodeError if the URI reference is Unicode and erroneously
+    contains non-ASCII characters.
+    """
+    # IDN support requires decoding any percent-encoded octets in the
+    # host part (if it's a reg-name) of the authority component, and when
+    # doing DNS lookups, applying IDNA encoding to that string first.
+    # As of Python 2.3, there is an IDNA codec, and the socket and httplib
+    # modules accept Unicode strings and apply IDNA encoding automatically
+    # where necessary. However, urllib.urlopen() has not yet been updated
+    # to do the same; it raises an exception if you give it a Unicode
+    # string, and does no conversion on non-Unicode strings, meaning you
+    # have to give it an IDNA string yourself. We will only support it on
+    # Python 2.3 and up.
+    #
+    # see if host is a reg-name, as opposed to IPv4 or IPv6 addr.
+    if isinstance(uriRef, unicode):
+        try:
+            uriRef = uriRef.encode('us-ascii') # parts of urllib are not unicode safe
+        except UnicodeError:
+            raise ValueError("uri %r must consist of ASCII characters." % uriRef)
+    (scheme, auth, path, query, frag) = urlparse.urlsplit(uriRef)
+    if auth and auth.find('@') > -1:
+        userinfo, hostport = auth.split('@')
+    else:
+        userinfo = None
+        hostport = auth
+    if hostport and hostport.find(':') > -1:
+        host, port = hostport.split(':')
+    else:
+        host = hostport
+        port = None
+    if host and REG_NAME_HOST_PATTERN.match(host):
+        # percent-encoded hostnames will always fail DNS lookups
+        host = urllib.unquote(host) #PercentDecode(host)
+        # IDNA-encode if possible.
+        # We shouldn't do this for schemes that don't need DNS lookup,
+        # but are there any (that you'd be calling urlopen for)?
+        if sys.version_info[0:2] >= (2, 3):
+            if isinstance(host, str):
+                host = host.decode('utf-8')
+            host = host.encode('idna')
+        # reassemble the authority with the new hostname
+        # (percent-decoded, and possibly IDNA-encoded)
+        auth = ''
+        if userinfo:
+            auth += userinfo + '@'
+        auth += host
+        if port:
+            auth += ':' + port
+
+    # On Windows, ensure that '|', not ':', is used in a drivespec.
+    if os.name == 'nt' and scheme == 'file':
+        path = path.replace(':', '|', 1)
+
+    # Note that we drop fragment, if any. See RFC 3986 sec. 3.5.
+    uri = urlparse.urlunsplit((scheme, auth, path, query, None))
+
+    return uri
+
+
+
+def BaseJoin(base, uriRef):
+    """
+    Merges a base URI reference with another URI reference, returning a
+    new URI reference.
+
+    It behaves exactly the same as Absolutize(), except the arguments
+    are reversed, and it accepts any URI reference (even a relative URI)
+    as the base URI. If the base has no scheme component, it is
+    evaluated as if it did, and then the scheme component of the result
+    is removed from the result, unless the uriRef had a scheme. Thus, if
+    neither argument has a scheme component, the result won't have one.
+
+    This function is named BaseJoin because it is very much like
+    urllib.basejoin(), but it follows the current rfc3986 algorithms
+    for path merging, dot segment elimination, and inheritance of query
+    and fragment components.
+
+    WARNING: This function exists for 2 reasons: (1) because of a need
+    within the 4Suite repository to perform URI reference absolutization
+    using base URIs that are stored (inappropriately) as absolute paths
+    in the subjects of statements in the RDF model, and (2) because of
+    a similar need to interpret relative repo paths in a 4Suite product
+    setup.xml file as being relative to a path that can be set outside
+    the document. When these needs go away, this function probably will,
+    too, so it is not advisable to use it.
+    """
+    if IsAbsolute(base):
+        return Absolutize(uriRef, base)
+    else:
+        dummyscheme = 'basejoin'
+        res = Absolutize(uriRef, '%s:%s' % (dummyscheme, base))
+        if IsAbsolute(uriRef):
+            # scheme will be inherited from uriRef
+            return res
+        else:
+            # no scheme in, no scheme out
+            return res[len(dummyscheme)+1:]
+
+
+def RemoveDotSegments(path):
+    """
+    Supports Absolutize() by implementing the remove_dot_segments function
+    described in RFC 3986 sec. 5.2.  It collapses most of the '.' and '..'
+    segments out of a path without eliminating empty segments. It is intended
+    to be used during the path merging process and may not give expected
+    results when used independently. Use NormalizePathSegments() or
+    NormalizePathSegmentsInUri() if more general normalization is desired.
+
+    semi-private because it is not for general use. I've implemented it
+    using two segment stacks, as alluded to in the spec, rather than the
+    explicit string-walking algorithm that would be too inefficient. (mbrown)
+    """
+    # return empty string if entire path is just "." or ".."
+    if path == '.' or path == '..':
+        return path[0:0] # preserves string type
+    # remove all "./" or "../" segments at the beginning
+    while path:
+        if path[:2] == './':
+            path = path[2:]
+        elif path[:3] == '../':
+            path = path[3:]
+        else:
+            break
+    # We need to keep track of whether there was a leading slash,
+    # because we're going to drop it in order to prevent our list of
+    # segments from having an ambiguous empty first item when we call
+    # split().
+    leading_slash = 0
+    if path[:1] == '/':
+        path = path[1:]
+        leading_slash = 1
+    # replace a trailing "/." with just "/"
+    if path[-2:] == '/.':
+        path = path[:-1]
+    # convert the segments into a list and process each segment in
+    # order from left to right.
+    segments = path.split('/')
+    keepers = []
+    segments.reverse()
+    while segments:
+        seg = segments.pop()
+        # '..' means drop the previous kept segment, if any.
+        # If none, and if the path is relative, then keep the '..'.
+        # If the '..' was the last segment, ensure
+        # that the result ends with '/'.
+        if seg == '..':
+            if keepers:
+                keepers.pop()
+            elif not leading_slash:
+                keepers.append(seg)
+            if not segments:
+                keepers.append('')
+        # ignore '.' segments and keep all others, even empty ones
+        elif seg != '.':
+            keepers.append(seg)
+    # reassemble the kept segments
+    return leading_slash * '/' + '/'.join(keepers)
+
+
+SCHEME_PATTERN = re.compile(r'([a-zA-Z][a-zA-Z0-9+\-.]*):')
+def GetScheme(uriRef):
+    """
+    Obtains, with optimum efficiency, just the scheme from a URI reference.
+    Returns a string, or if no scheme could be found, returns None.
+    """
+    # Using a regex seems to be the best option. Called 50,000 times on
+    # different URIs, on a 1.0-GHz PIII with FreeBSD 4.7 and Python
+    # 2.2.1, this method completed in 0.95s, and 0.05s if there was no
+    # scheme to find. By comparison,
+    #   urllib.splittype()[0] took 1.5s always;
+    #   Ft.Lib.Uri.SplitUriRef()[0] took 2.5s always;
+    #   urlparse.urlparse()[0] took 3.5s always.
+    m = SCHEME_PATTERN.match(uriRef)
+    if m is None:
+        return None
+    else:
+        return m.group(1)
+
+
+def IsAbsolute(identifier):
+    """
+    Given a string believed to be a URI or URI reference, tests that it is
+    absolute (as per RFC 2396), not relative -- i.e., that it has a scheme.
+    """
+    # We do it this way to avoid compiling another massive regex.
+    return GetScheme(identifier) is not None

plugins/Jython/Lib/xml/__init__.py

@@ -0,0 +1,36 @@
+"""Core XML support for Jython.
+
+This package contains two sub-packages:
+
+dom -- The W3C Document Object Model.  This supports DOM Level 1 +
+       Namespaces.
+
+sax -- The Simple API for XML, developed by XML-Dev, led by David
+       Megginson and ported to Python by Lars Marius Garshol.  This
+       supports the SAX 2 API.
+
+"""
+
+__all__ = ['dom', 'sax']
+
+
+_MINIMUM_XMLPLUS_VERSION = (0, 8, 5)
+
+
+try:
+    import _xmlplus
+except ImportError:
+    pass
+else:
+    try:
+        v = _xmlplus.version_info
+    except AttributeError:
+        # _xmlplus is too old; ignore it
+        pass
+    else:
+        if v >= _MINIMUM_XMLPLUS_VERSION:
+            import sys
+            _xmlplus.__path__.extend(__path__)
+            sys.modules[__name__] = _xmlplus
+        else:
+            del v

plugins/Jython/Lib/xml/dom/NodeFilter.py

@@ -0,0 +1,27 @@
+# This is the Python mapping for interface NodeFilter from
+# DOM2-Traversal-Range. It contains only constants.
+
+class NodeFilter:
+    """
+    This is the DOM2 NodeFilter interface. It contains only constants.
+    """
+    FILTER_ACCEPT = 1
+    FILTER_REJECT = 2
+    FILTER_SKIP   = 3
+
+    SHOW_ALL                    = 0xFFFFFFFFL
+    SHOW_ELEMENT                = 0x00000001
+    SHOW_ATTRIBUTE              = 0x00000002
+    SHOW_TEXT                   = 0x00000004
+    SHOW_CDATA_SECTION          = 0x00000008
+    SHOW_ENTITY_REFERENCE       = 0x00000010
+    SHOW_ENTITY                 = 0x00000020
+    SHOW_PROCESSING_INSTRUCTION = 0x00000040
+    SHOW_COMMENT                = 0x00000080
+    SHOW_DOCUMENT               = 0x00000100
+    SHOW_DOCUMENT_TYPE          = 0x00000200
+    SHOW_DOCUMENT_FRAGMENT      = 0x00000400
+    SHOW_NOTATION               = 0x00000800
+
+    def acceptNode(self, node):
+        raise NotImplementedError

plugins/Jython/Lib/xml/dom/__init__.py

@@ -0,0 +1,139 @@
+"""W3C Document Object Model implementation for Python.
+
+The Python mapping of the Document Object Model is documented in the
+Python Library Reference in the section on the xml.dom package.
+
+This package contains the following modules:
+
+minidom -- A simple implementation of the Level 1 DOM with namespace
+           support added (based on the Level 2 specification) and other
+           minor Level 2 functionality.
+
+pulldom -- DOM builder supporting on-demand tree-building for selected
+           subtrees of the document.
+
+"""
+
+
+class Node:
+    """Class giving the NodeType constants."""
+
+    # DOM implementations may use this as a base class for their own
+    # Node implementations.  If they don't, the constants defined here
+    # should still be used as the canonical definitions as they match
+    # the values given in the W3C recommendation.  Client code can
+    # safely refer to these values in all tests of Node.nodeType
+    # values.
+
+    ELEMENT_NODE                = 1
+    ATTRIBUTE_NODE              = 2
+    TEXT_NODE                   = 3
+    CDATA_SECTION_NODE          = 4
+    ENTITY_REFERENCE_NODE       = 5
+    ENTITY_NODE                 = 6
+    PROCESSING_INSTRUCTION_NODE = 7
+    COMMENT_NODE                = 8
+    DOCUMENT_NODE               = 9
+    DOCUMENT_TYPE_NODE          = 10
+    DOCUMENT_FRAGMENT_NODE      = 11
+    NOTATION_NODE               = 12
+
+
+#ExceptionCode
+INDEX_SIZE_ERR                 = 1
+DOMSTRING_SIZE_ERR             = 2
+HIERARCHY_REQUEST_ERR          = 3
+WRONG_DOCUMENT_ERR             = 4
+INVALID_CHARACTER_ERR          = 5
+NO_DATA_ALLOWED_ERR            = 6
+NO_MODIFICATION_ALLOWED_ERR    = 7
+NOT_FOUND_ERR                  = 8
+NOT_SUPPORTED_ERR              = 9
+INUSE_ATTRIBUTE_ERR            = 10
+INVALID_STATE_ERR              = 11
+SYNTAX_ERR                     = 12
+INVALID_MODIFICATION_ERR       = 13
+NAMESPACE_ERR                  = 14
+INVALID_ACCESS_ERR             = 15
+VALIDATION_ERR                 = 16
+
+
+class DOMException(Exception):
+    """Abstract base class for DOM exceptions.
+    Exceptions with specific codes are specializations of this class."""
+
+    def __init__(self, *args, **kw):
+        if self.__class__ is DOMException:
+            raise RuntimeError(
+                "DOMException should not be instantiated directly")
+        Exception.__init__(self, *args, **kw)
+
+    def _get_code(self):
+        return self.code
+
+
+class IndexSizeErr(DOMException):
+    code = INDEX_SIZE_ERR
+
+class DomstringSizeErr(DOMException):
+    code = DOMSTRING_SIZE_ERR
+
+class HierarchyRequestErr(DOMException):
+    code = HIERARCHY_REQUEST_ERR
+
+class WrongDocumentErr(DOMException):
+    code = WRONG_DOCUMENT_ERR
+
+class InvalidCharacterErr(DOMException):
+    code = INVALID_CHARACTER_ERR
+
+class NoDataAllowedErr(DOMException):
+    code = NO_DATA_ALLOWED_ERR
+
+class NoModificationAllowedErr(DOMException):
+    code = NO_MODIFICATION_ALLOWED_ERR
+
+class NotFoundErr(DOMException):
+    code = NOT_FOUND_ERR
+
+class NotSupportedErr(DOMException):
+    code = NOT_SUPPORTED_ERR
+
+class InuseAttributeErr(DOMException):
+    code = INUSE_ATTRIBUTE_ERR
+
+class InvalidStateErr(DOMException):
+    code = INVALID_STATE_ERR
+
+class SyntaxErr(DOMException):
+    code = SYNTAX_ERR
+
+class InvalidModificationErr(DOMException):
+    code = INVALID_MODIFICATION_ERR
+
+class NamespaceErr(DOMException):
+    code = NAMESPACE_ERR
+
+class InvalidAccessErr(DOMException):
+    code = INVALID_ACCESS_ERR
+
+class ValidationErr(DOMException):
+    code = VALIDATION_ERR
+
+class UserDataHandler:
+    """Class giving the operation constants for UserDataHandler.handle()."""
+
+    # Based on DOM Level 3 (WD 9 April 2002)
+
+    NODE_CLONED   = 1
+    NODE_IMPORTED = 2
+    NODE_DELETED  = 3
+    NODE_RENAMED  = 4
+
+XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
+XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
+XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml"
+EMPTY_NAMESPACE = None
+EMPTY_PREFIX = None
+
+from domreg import getDOMImplementation,registerDOMImplementation

plugins/Jython/Lib/xml/dom/domreg.py

@@ -0,0 +1,99 @@
+"""Registration facilities for DOM. This module should not be used
+directly. Instead, the functions getDOMImplementation and
+registerDOMImplementation should be imported from xml.dom."""
+
+from xml.dom.minicompat import *  # isinstance, StringTypes
+
+# This is a list of well-known implementations.  Well-known names
+# should be published by posting to xml-sig@python.org, and are
+# subsequently recorded in this file.
+
+well_known_implementations = {
+    'minidom':'xml.dom.minidom',
+    '4DOM': 'xml.dom.DOMImplementation',
+    }
+
+# DOM implementations not officially registered should register
+# themselves with their
+
+registered = {}
+
+def registerDOMImplementation(name, factory):
+    """registerDOMImplementation(name, factory)
+
+    Register the factory function with the name. The factory function
+    should return an object which implements the DOMImplementation
+    interface. The factory function can either return the same object,
+    or a new one (e.g. if that implementation supports some
+    customization)."""
+
+    registered[name] = factory
+
+def _good_enough(dom, features):
+    "_good_enough(dom, features) -> Return 1 if the dom offers the features"
+    for f,v in features:
+        if not dom.hasFeature(f,v):
+            return 0
+    return 1
+
+def getDOMImplementation(name = None, features = ()):
+    """getDOMImplementation(name = None, features = ()) -> DOM implementation.
+
+    Return a suitable DOM implementation. The name is either
+    well-known, the module name of a DOM implementation, or None. If
+    it is not None, imports the corresponding module and returns
+    DOMImplementation object if the import succeeds.
+
+    If name is not given, consider the available implementations to
+    find one with the required feature set. If no implementation can
+    be found, raise an ImportError. The features list must be a sequence
+    of (feature, version) pairs which are passed to hasFeature."""
+
+    import os
+    creator = None
+    mod = well_known_implementations.get(name)
+    if mod:
+        mod = __import__(mod, {}, {}, ['getDOMImplementation'])
+        return mod.getDOMImplementation()
+    elif name:
+        return registered[name]()
+    elif "PYTHON_DOM" in os.environ:
+        return getDOMImplementation(name = os.environ["PYTHON_DOM"])
+
+    # User did not specify a name, try implementations in arbitrary
+    # order, returning the one that has the required features
+    if isinstance(features, StringTypes):
+        features = _parse_feature_string(features)
+    for creator in registered.values():
+        dom = creator()
+        if _good_enough(dom, features):
+            return dom
+
+    for creator in well_known_implementations.keys():
+        try:
+            dom = getDOMImplementation(name = creator)
+        except StandardError: # typically ImportError, or AttributeError
+            continue
+        if _good_enough(dom, features):
+            return dom
+
+    raise ImportError,"no suitable DOM implementation found"
+
+def _parse_feature_string(s):
+    features = []
+    parts = s.split()
+    i = 0
+    length = len(parts)
+    while i < length:
+        feature = parts[i]
+        if feature[0] in "0123456789":
+            raise ValueError, "bad feature name: %r" % (feature,)
+        i = i + 1
+        version = None
+        if i < length:
+            v = parts[i]
+            if v[0] in "0123456789":
+                i = i + 1
+                version = v
+        features.append((feature, version))
+    return tuple(features)

plugins/Jython/Lib/xml/dom/expatbuilder.py

@@ -0,0 +1,983 @@
+"""Facility to use the Expat parser to load a minidom instance
+from a string or file.
+
+This avoids all the overhead of SAX and pulldom to gain performance.
+"""
+
+# Warning!
+#
+# This module is tightly bound to the implementation details of the
+# minidom DOM and can't be used with other DOM implementations.  This
+# is due, in part, to a lack of appropriate methods in the DOM (there is
+# no way to create Entity and Notation nodes via the DOM Level 2
+# interface), and for performance.  The later is the cause of some fairly
+# cryptic code.
+#
+# Performance hacks:
+#
+#   -  .character_data_handler() has an extra case in which continuing
+#      data is appended to an existing Text node; this can be a
+#      speedup since pyexpat can break up character data into multiple
+#      callbacks even though we set the buffer_text attribute on the
+#      parser.  This also gives us the advantage that we don't need a
+#      separate normalization pass.
+#
+#   -  Determining that a node exists is done using an identity comparison
+#      with None rather than a truth test; this avoids searching for and
+#      calling any methods on the node object if it exists.  (A rather
+#      nice speedup is achieved this way as well!)
+
+from xml.dom import xmlbuilder, minidom, Node
+from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE
+from xml.parsers import expat
+from xml.dom.minidom import _append_child, _set_attribute_node
+from xml.dom.NodeFilter import NodeFilter
+
+from xml.dom.minicompat import *
+
+TEXT_NODE = Node.TEXT_NODE
+CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE
+DOCUMENT_NODE = Node.DOCUMENT_NODE
+
+FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT
+FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT
+FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP
+FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT
+
+theDOMImplementation = minidom.getDOMImplementation()
+
+# Expat typename -> TypeInfo
+_typeinfo_map = {
+    "CDATA":    minidom.TypeInfo(None, "cdata"),
+    "ENUM":     minidom.TypeInfo(None, "enumeration"),
+    "ENTITY":   minidom.TypeInfo(None, "entity"),
+    "ENTITIES": minidom.TypeInfo(None, "entities"),
+    "ID":       minidom.TypeInfo(None, "id"),
+    "IDREF":    minidom.TypeInfo(None, "idref"),
+    "IDREFS":   minidom.TypeInfo(None, "idrefs"),
+    "NMTOKEN":  minidom.TypeInfo(None, "nmtoken"),
+    "NMTOKENS": minidom.TypeInfo(None, "nmtokens"),
+    }
+
+class ElementInfo(object):
+    __slots__ = '_attr_info', '_model', 'tagName'
+
+    def __init__(self, tagName, model=None):
+        self.tagName = tagName
+        self._attr_info = []
+        self._model = model
+
+    def __getstate__(self):
+        return self._attr_info, self._model, self.tagName
+
+    def __setstate__(self, state):
+        self._attr_info, self._model, self.tagName = state
+
+    def getAttributeType(self, aname):
+        for info in self._attr_info:
+            if info[1] == aname:
+                t = info[-2]
+                if t[0] == "(":
+                    return _typeinfo_map["ENUM"]
+                else:
+                    return _typeinfo_map[info[-2]]
+        return minidom._no_type
+
+    def getAttributeTypeNS(self, namespaceURI, localName):
+        return minidom._no_type
+
+    def isElementContent(self):
+        if self._model:
+            type = self._model[0]
+            return type not in (expat.model.XML_CTYPE_ANY,
+                                expat.model.XML_CTYPE_MIXED)
+        else:
+            return False
+
+    def isEmpty(self):
+        if self._model:
+            return self._model[0] == expat.model.XML_CTYPE_EMPTY
+        else:
+            return False
+
+    def isId(self, aname):
+        for info in self._attr_info:
+            if info[1] == aname:
+                return info[-2] == "ID"
+        return False
+
+    def isIdNS(self, euri, ename, auri, aname):
+        # not sure this is meaningful
+        return self.isId((auri, aname))
+
+def _intern(builder, s):
+    return builder._intern_setdefault(s, s)
+
+def _parse_ns_name(builder, name):
+    assert ' ' in name
+    parts = name.split(' ')
+    intern = builder._intern_setdefault
+    if len(parts) == 3:
+        uri, localname, prefix = parts
+        prefix = intern(prefix, prefix)
+        qname = "%s:%s" % (prefix, localname)
+        qname = intern(qname, qname)
+        localname = intern(localname, localname)
+    else:
+        uri, localname = parts
+        prefix = EMPTY_PREFIX
+        qname = localname = intern(localname, localname)
+    return intern(uri, uri), localname, prefix, qname
+
+
+class ExpatBuilder:
+    """Document builder that uses Expat to build a ParsedXML.DOM document
+    instance."""
+
+    def __init__(self, options=None):
+        if options is None:
+            options = xmlbuilder.Options()
+        self._options = options
+        if self._options.filter is not None:
+            self._filter = FilterVisibilityController(self._options.filter)
+        else:
+            self._filter = None
+            # This *really* doesn't do anything in this case, so
+            # override it with something fast & minimal.
+            self._finish_start_element = id
+        self._parser = None
+        self.reset()
+
+    def createParser(self):
+        """Create a new parser object."""
+        return expat.ParserCreate()
+
+    def getParser(self):
+        """Return the parser object, creating a new one if needed."""
+        if not self._parser:
+            self._parser = self.createParser()
+            self._intern_setdefault = self._parser.intern.setdefault
+            self._parser.buffer_text = True
+            self._parser.ordered_attributes = True
+            self._parser.specified_attributes = True
+            self.install(self._parser)
+        return self._parser
+
+    def reset(self):
+        """Free all data structures used during DOM construction."""
+        self.document = theDOMImplementation.createDocument(
+            EMPTY_NAMESPACE, None, None)
+        self.curNode = self.document
+        self._elem_info = self.document._elem_info
+        self._cdata = False
+
+    def install(self, parser):
+        """Install the callbacks needed to build the DOM into the parser."""
+        # This creates circular references!
+        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
+        parser.StartElementHandler = self.first_element_handler
+        parser.EndElementHandler = self.end_element_handler
+        parser.ProcessingInstructionHandler = self.pi_handler
+        if self._options.entities:
+            parser.EntityDeclHandler = self.entity_decl_handler
+        parser.NotationDeclHandler = self.notation_decl_handler
+        if self._options.comments:
+            parser.CommentHandler = self.comment_handler
+        if self._options.cdata_sections:
+            parser.StartCdataSectionHandler = self.start_cdata_section_handler
+            parser.EndCdataSectionHandler = self.end_cdata_section_handler
+            parser.CharacterDataHandler = self.character_data_handler_cdata
+        else:
+            parser.CharacterDataHandler = self.character_data_handler
+        parser.ExternalEntityRefHandler = self.external_entity_ref_handler
+        parser.XmlDeclHandler = self.xml_decl_handler
+        parser.ElementDeclHandler = self.element_decl_handler
+        parser.AttlistDeclHandler = self.attlist_decl_handler
+
+    def parseFile(self, file):
+        """Parse a document from a file object, returning the document
+        node."""
+        parser = self.getParser()
+        first_buffer = True
+        try:
+            while 1:
+                buffer = file.read(16*1024)
+                if not buffer:
+                    break
+                parser.Parse(buffer, 0)
+                if first_buffer and self.document.documentElement:
+                    self._setup_subset(buffer)
+                first_buffer = False
+            parser.Parse("", True)
+        except ParseEscape:
+            pass
+        doc = self.document
+        self.reset()
+        self._parser = None
+        return doc
+
+    def parseString(self, string):
+        """Parse a document from a string, returning the document node."""
+        parser = self.getParser()
+        try:
+            parser.Parse(string, True)
+            self._setup_subset(string)
+        except ParseEscape:
+            pass
+        doc = self.document
+        self.reset()
+        self._parser = None
+        return doc
+
+    def _setup_subset(self, buffer):
+        """Load the internal subset if there might be one."""
+        if self.document.doctype:
+            extractor = InternalSubsetExtractor()
+            extractor.parseString(buffer)
+            subset = extractor.getSubset()
+            self.document.doctype.internalSubset = subset
+
+    def start_doctype_decl_handler(self, doctypeName, systemId, publicId,
+                                   has_internal_subset):
+        doctype = self.document.implementation.createDocumentType(
+            doctypeName, publicId, systemId)
+        doctype.ownerDocument = self.document
+        _append_child(self.document, doctype)
+        self.document.doctype = doctype
+        if self._filter and self._filter.acceptNode(doctype) == FILTER_REJECT:
+            self.document.doctype = None
+            del self.document.childNodes[-1]
+            doctype = None
+            self._parser.EntityDeclHandler = None
+            self._parser.NotationDeclHandler = None
+        if has_internal_subset:
+            if doctype is not None:
+                doctype.entities._seq = []
+                doctype.notations._seq = []
+            self._parser.CommentHandler = None
+            self._parser.ProcessingInstructionHandler = None
+            self._parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler
+
+    def end_doctype_decl_handler(self):
+        if self._options.comments:
+            self._parser.CommentHandler = self.comment_handler
+        self._parser.ProcessingInstructionHandler = self.pi_handler
+        if not (self._elem_info or self._filter):
+            self._finish_end_element = id
+
+    def pi_handler(self, target, data):
+        node = self.document.createProcessingInstruction(target, data)
+        _append_child(self.curNode, node)
+        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
+            self.curNode.removeChild(node)
+
+    def character_data_handler_cdata(self, data):
+        childNodes = self.curNode.childNodes
+        if self._cdata:
+            if (  self._cdata_continue
+                  and childNodes[-1].nodeType == CDATA_SECTION_NODE):
+                childNodes[-1].appendData(data)
+                return
+            node = self.document.createCDATASection(data)
+            self._cdata_continue = True
+        elif childNodes and childNodes[-1].nodeType == TEXT_NODE:
+            node = childNodes[-1]
+            value = node.data + data
+            d = node.__dict__
+            d['data'] = d['nodeValue'] = value
+            return
+        else:
+            node = minidom.Text()
+            d = node.__dict__
+            d['data'] = d['nodeValue'] = data
+            d['ownerDocument'] = self.document
+        _append_child(self.curNode, node)
+
+    def character_data_handler(self, data):
+        childNodes = self.curNode.childNodes
+        if childNodes and childNodes[-1].nodeType == TEXT_NODE:
+            node = childNodes[-1]
+            d = node.__dict__
+            d['data'] = d['nodeValue'] = node.data + data
+            return
+        node = minidom.Text()
+        d = node.__dict__
+        d['data'] = d['nodeValue'] = node.data + data
+        d['ownerDocument'] = self.document
+        _append_child(self.curNode, node)
+
+    def entity_decl_handler(self, entityName, is_parameter_entity, value,
+                            base, systemId, publicId, notationName):
+        if is_parameter_entity:
+            # we don't care about parameter entities for the DOM
+            return
+        if not self._options.entities:
+            return
+        node = self.document._create_entity(entityName, publicId,
+                                            systemId, notationName)
+        if value is not None:
+            # internal entity
+            # node *should* be readonly, but we'll cheat
+            child = self.document.createTextNode(value)
+            node.childNodes.append(child)
+        self.document.doctype.entities._seq.append(node)
+        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
+            del self.document.doctype.entities._seq[-1]
+
+    def notation_decl_handler(self, notationName, base, systemId, publicId):
+        node = self.document._create_notation(notationName, publicId, systemId)
+        self.document.doctype.notations._seq.append(node)
+        if self._filter and self._filter.acceptNode(node) == FILTER_ACCEPT:
+            del self.document.doctype.notations._seq[-1]
+
+    def comment_handler(self, data):
+        node = self.document.createComment(data)
+        _append_child(self.curNode, node)
+        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
+            self.curNode.removeChild(node)
+
+    def start_cdata_section_handler(self):
+        self._cdata = True
+        self._cdata_continue = False
+
+    def end_cdata_section_handler(self):
+        self._cdata = False
+        self._cdata_continue = False
+
+    def external_entity_ref_handler(self, context, base, systemId, publicId):
+        return 1
+
+    def first_element_handler(self, name, attributes):
+        if self._filter is None and not self._elem_info:
+            self._finish_end_element = id
+        self.getParser().StartElementHandler = self.start_element_handler
+        self.start_element_handler(name, attributes)
+
+    def start_element_handler(self, name, attributes):
+        node = self.document.createElement(name)
+        _append_child(self.curNode, node)
+        self.curNode = node
+
+        if attributes:
+            for i in range(0, len(attributes), 2):
+                a = minidom.Attr(attributes[i], EMPTY_NAMESPACE,
+                                 None, EMPTY_PREFIX)
+                value = attributes[i+1]
+                d = a.childNodes[0].__dict__
+                d['data'] = d['nodeValue'] = value
+                d = a.__dict__
+                d['value'] = d['nodeValue'] = value
+                d['ownerDocument'] = self.document
+                _set_attribute_node(node, a)
+
+        if node is not self.document.documentElement:
+            self._finish_start_element(node)
+
+    def _finish_start_element(self, node):
+        if self._filter:
+            # To be general, we'd have to call isSameNode(), but this
+            # is sufficient for minidom:
+            if node is self.document.documentElement:
+                return
+            filt = self._filter.startContainer(node)
+            if filt == FILTER_REJECT:
+                # ignore this node & all descendents
+                Rejecter(self)
+            elif filt == FILTER_SKIP:
+                # ignore this node, but make it's children become
+                # children of the parent node
+                Skipper(self)
+            else:
+                return
+            self.curNode = node.parentNode
+            node.parentNode.removeChild(node)
+            node.unlink()
+
+    # If this ever changes, Namespaces.end_element_handler() needs to
+    # be changed to match.
+    #
+    def end_element_handler(self, name):
+        curNode = self.curNode
+        self.curNode = curNode.parentNode
+        self._finish_end_element(curNode)
+
+    def _finish_end_element(self, curNode):
+        info = self._elem_info.get(curNode.tagName)
+        if info:
+            self._handle_white_text_nodes(curNode, info)
+        if self._filter:
+            if curNode is self.document.documentElement:
+                return
+            if self._filter.acceptNode(curNode) == FILTER_REJECT:
+                self.curNode.removeChild(curNode)
+                curNode.unlink()
+
+    def _handle_white_text_nodes(self, node, info):
+        if (self._options.whitespace_in_element_content
+            or not info.isElementContent()):
+            return
+
+        # We have element type information and should remove ignorable
+        # whitespace; identify for text nodes which contain only
+        # whitespace.
+        L = []
+        for child in node.childNodes:
+            if child.nodeType == TEXT_NODE and not child.data.strip():
+                L.append(child)
+
+        # Remove ignorable whitespace from the tree.
+        for child in L:
+            node.removeChild(child)
+
+    def element_decl_handler(self, name, model):
+        info = self._elem_info.get(name)
+        if info is None:
+            self._elem_info[name] = ElementInfo(name, model)
+        else:
+            assert info._model is None
+            info._model = model
+
+    def attlist_decl_handler(self, elem, name, type, default, required):
+        info = self._elem_info.get(elem)
+        if info is None:
+            info = ElementInfo(elem)
+            self._elem_info[elem] = info
+        info._attr_info.append(
+            [None, name, None, None, default, 0, type, required])
+
+    def xml_decl_handler(self, version, encoding, standalone):
+        self.document.version = version
+        self.document.encoding = encoding
+        # This is still a little ugly, thanks to the pyexpat API. ;-(
+        if standalone >= 0:
+            if standalone:
+                self.document.standalone = True
+            else:
+                self.document.standalone = False
+
+
+# Don't include FILTER_INTERRUPT, since that's checked separately
+# where allowed.
+_ALLOWED_FILTER_RETURNS = (FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP)
+
+class FilterVisibilityController(object):
+    """Wrapper around a DOMBuilderFilter which implements the checks
+    to make the whatToShow filter attribute work."""
+
+    __slots__ = 'filter',
+
+    def __init__(self, filter):
+        self.filter = filter
+
+    def startContainer(self, node):
+        mask = self._nodetype_mask[node.nodeType]
+        if self.filter.whatToShow & mask:
+            val = self.filter.startContainer(node)
+            if val == FILTER_INTERRUPT:
+                raise ParseEscape
+            if val not in _ALLOWED_FILTER_RETURNS:
+                raise ValueError, \
+                      "startContainer() returned illegal value: " + repr(val)
+            return val
+        else:
+            return FILTER_ACCEPT
+
+    def acceptNode(self, node):
+        mask = self._nodetype_mask[node.nodeType]
+        if self.filter.whatToShow & mask:
+            val = self.filter.acceptNode(node)
+            if val == FILTER_INTERRUPT:
+                raise ParseEscape
+            if val == FILTER_SKIP:
+                # move all child nodes to the parent, and remove this node
+                parent = node.parentNode
+                for child in node.childNodes[:]:
+                    parent.appendChild(child)
+                # node is handled by the caller
+                return FILTER_REJECT
+            if val not in _ALLOWED_FILTER_RETURNS:
+                raise ValueError, \
+                      "acceptNode() returned illegal value: " + repr(val)
+            return val
+        else:
+            return FILTER_ACCEPT
+
+    _nodetype_mask = {
+        Node.ELEMENT_NODE:                NodeFilter.SHOW_ELEMENT,
+        Node.ATTRIBUTE_NODE:              NodeFilter.SHOW_ATTRIBUTE,
+        Node.TEXT_NODE:                   NodeFilter.SHOW_TEXT,
+        Node.CDATA_SECTION_NODE:          NodeFilter.SHOW_CDATA_SECTION,
+        Node.ENTITY_REFERENCE_NODE:       NodeFilter.SHOW_ENTITY_REFERENCE,
+        Node.ENTITY_NODE:                 NodeFilter.SHOW_ENTITY,
+        Node.PROCESSING_INSTRUCTION_NODE: NodeFilter.SHOW_PROCESSING_INSTRUCTION,
+        Node.COMMENT_NODE:                NodeFilter.SHOW_COMMENT,
+        Node.DOCUMENT_NODE:               NodeFilter.SHOW_DOCUMENT,
+        Node.DOCUMENT_TYPE_NODE:          NodeFilter.SHOW_DOCUMENT_TYPE,
+        Node.DOCUMENT_FRAGMENT_NODE:      NodeFilter.SHOW_DOCUMENT_FRAGMENT,
+        Node.NOTATION_NODE:               NodeFilter.SHOW_NOTATION,
+        }
+
+
+class FilterCrutch(object):
+    __slots__ = '_builder', '_level', '_old_start', '_old_end'
+
+    def __init__(self, builder):
+        self._level = 0
+        self._builder = builder
+        parser = builder._parser
+        self._old_start = parser.StartElementHandler
+        self._old_end = parser.EndElementHandler
+        parser.StartElementHandler = self.start_element_handler
+        parser.EndElementHandler = self.end_element_handler
+
+class Rejecter(FilterCrutch):
+    __slots__ = ()
+
+    def __init__(self, builder):
+        FilterCrutch.__init__(self, builder)
+        parser = builder._parser
+        for name in ("ProcessingInstructionHandler",
+                     "CommentHandler",
+                     "CharacterDataHandler",
+                     "StartCdataSectionHandler",
+                     "EndCdataSectionHandler",
+                     "ExternalEntityRefHandler",
+                     ):
+            setattr(parser, name, None)
+
+    def start_element_handler(self, *args):
+        self._level = self._level + 1
+
+    def end_element_handler(self, *args):
+        if self._level == 0:
+            # restore the old handlers
+            parser = self._builder._parser
+            self._builder.install(parser)
+            parser.StartElementHandler = self._old_start
+            parser.EndElementHandler = self._old_end
+        else:
+            self._level = self._level - 1
+
+class Skipper(FilterCrutch):
+    __slots__ = ()
+
+    def start_element_handler(self, *args):
+        node = self._builder.curNode
+        self._old_start(*args)
+        if self._builder.curNode is not node:
+            self._level = self._level + 1
+
+    def end_element_handler(self, *args):
+        if self._level == 0:
+            # We're popping back out of the node we're skipping, so we
+            # shouldn't need to do anything but reset the handlers.
+            self._builder._parser.StartElementHandler = self._old_start
+            self._builder._parser.EndElementHandler = self._old_end
+            self._builder = None
+        else:
+            self._level = self._level - 1
+            self._old_end(*args)
+
+
+# framework document used by the fragment builder.
+# Takes a string for the doctype, subset string, and namespace attrs string.
+
+_FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID = \
+    "http://xml.python.org/entities/fragment-builder/internal"
+
+_FRAGMENT_BUILDER_TEMPLATE = (
+    '''\
+<!DOCTYPE wrapper
+  %%s [
+  <!ENTITY fragment-builder-internal
+    SYSTEM "%s">
+%%s
+]>
+<wrapper %%s
+>&fragment-builder-internal;</wrapper>'''
+    % _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID)
+
+
+class FragmentBuilder(ExpatBuilder):
+    """Builder which constructs document fragments given XML source
+    text and a context node.
+
+    The context node is expected to provide information about the
+    namespace declarations which are in scope at the start of the
+    fragment.
+    """
+
+    def __init__(self, context, options=None):
+        if context.nodeType == DOCUMENT_NODE:
+            self.originalDocument = context
+            self.context = context
+        else:
+            self.originalDocument = context.ownerDocument
+            self.context = context
+        ExpatBuilder.__init__(self, options)
+
+    def reset(self):
+        ExpatBuilder.reset(self)
+        self.fragment = None
+
+    def parseFile(self, file):
+        """Parse a document fragment from a file object, returning the
+        fragment node."""
+        return self.parseString(file.read())
+
+    def parseString(self, string):
+        """Parse a document fragment from a string, returning the
+        fragment node."""
+        self._source = string
+        parser = self.getParser()
+        doctype = self.originalDocument.doctype
+        ident = ""
+        if doctype:
+            subset = doctype.internalSubset or self._getDeclarations()
+            if doctype.publicId:
+                ident = ('PUBLIC "%s" "%s"'
+                         % (doctype.publicId, doctype.systemId))
+            elif doctype.systemId:
+                ident = 'SYSTEM "%s"' % doctype.systemId
+        else:
+            subset = ""
+        nsattrs = self._getNSattrs() # get ns decls from node's ancestors
+        document = _FRAGMENT_BUILDER_TEMPLATE % (ident, subset, nsattrs)
+        try:
+            parser.Parse(document, 1)
+        except:
+            self.reset()
+            raise
+        fragment = self.fragment
+        self.reset()
+##         self._parser = None
+        return fragment
+
+    def _getDeclarations(self):
+        """Re-create the internal subset from the DocumentType node.
+
+        This is only needed if we don't already have the
+        internalSubset as a string.
+        """
+        doctype = self.context.ownerDocument.doctype
+        s = ""
+        if doctype:
+            for i in range(doctype.notations.length):
+                notation = doctype.notations.item(i)
+                if s:
+                    s = s + "\n  "
+                s = "%s<!NOTATION %s" % (s, notation.nodeName)
+                if notation.publicId:
+                    s = '%s PUBLIC "%s"\n             "%s">' \
+                        % (s, notation.publicId, notation.systemId)
+                else:
+                    s = '%s SYSTEM "%s">' % (s, notation.systemId)
+            for i in range(doctype.entities.length):
+                entity = doctype.entities.item(i)
+                if s:
+                    s = s + "\n  "
+                s = "%s<!ENTITY %s" % (s, entity.nodeName)
+                if entity.publicId:
+                    s = '%s PUBLIC "%s"\n             "%s"' \
+                        % (s, entity.publicId, entity.systemId)
+                elif entity.systemId:
+                    s = '%s SYSTEM "%s"' % (s, entity.systemId)
+                else:
+                    s = '%s "%s"' % (s, entity.firstChild.data)
+                if entity.notationName:
+                    s = "%s NOTATION %s" % (s, entity.notationName)
+                s = s + ">"
+        return s
+
+    def _getNSattrs(self):
+        return ""
+
+    def external_entity_ref_handler(self, context, base, systemId, publicId):
+        if systemId == _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID:
+            # this entref is the one that we made to put the subtree
+            # in; all of our given input is parsed in here.
+            old_document = self.document
+            old_cur_node = self.curNode
+            parser = self._parser.ExternalEntityParserCreate(context)
+            # put the real document back, parse into the fragment to return
+            self.document = self.originalDocument
+            self.fragment = self.document.createDocumentFragment()
+            self.curNode = self.fragment
+            try:
+                parser.Parse(self._source, 1)
+            finally:
+                self.curNode = old_cur_node
+                self.document = old_document
+                self._source = None
+            return -1
+        else:
+            return ExpatBuilder.external_entity_ref_handler(
+                self, context, base, systemId, publicId)
+
+
+class Namespaces:
+    """Mix-in class for builders; adds support for namespaces."""
+
+    def _initNamespaces(self):
+        # list of (prefix, uri) ns declarations.  Namespace attrs are
+        # constructed from this and added to the element's attrs.
+        self._ns_ordered_prefixes = []
+
+    def createParser(self):
+        """Create a new namespace-handling parser."""
+        parser = expat.ParserCreate(namespace_separator=" ")
+        parser.namespace_prefixes = True
+        return parser
+
+    def install(self, parser):
+        """Insert the namespace-handlers onto the parser."""
+        ExpatBuilder.install(self, parser)
+        if self._options.namespace_declarations:
+            parser.StartNamespaceDeclHandler = (
+                self.start_namespace_decl_handler)
+
+    def start_namespace_decl_handler(self, prefix, uri):
+        """Push this namespace declaration on our storage."""
+        self._ns_ordered_prefixes.append((prefix, uri))
+
+    def start_element_handler(self, name, attributes):
+        if ' ' in name:
+            uri, localname, prefix, qname = _parse_ns_name(self, name)
+        else:
+            uri = EMPTY_NAMESPACE
+            qname = name
+            localname = None
+            prefix = EMPTY_PREFIX
+        node = minidom.Element(qname, uri, prefix, localname)
+        node.ownerDocument = self.document
+        _append_child(self.curNode, node)
+        self.curNode = node
+
+        if self._ns_ordered_prefixes:
+            for prefix, uri in self._ns_ordered_prefixes:
+                if prefix:
+                    a = minidom.Attr(_intern(self, 'xmlns:' + prefix),
+                                     XMLNS_NAMESPACE, prefix, "xmlns")
+                else:
+                    a = minidom.Attr("xmlns", XMLNS_NAMESPACE,
+                                     "xmlns", EMPTY_PREFIX)
+                d = a.childNodes[0].__dict__
+                d['data'] = d['nodeValue'] = uri
+                d = a.__dict__
+                d['value'] = d['nodeValue'] = uri
+                d['ownerDocument'] = self.document
+                _set_attribute_node(node, a)
+            del self._ns_ordered_prefixes[:]
+
+        if attributes:
+            _attrs = node._attrs
+            _attrsNS = node._attrsNS
+            for i in range(0, len(attributes), 2):
+                aname = attributes[i]
+                value = attributes[i+1]
+                if ' ' in aname:
+                    uri, localname, prefix, qname = _parse_ns_name(self, aname)
+                    a = minidom.Attr(qname, uri, localname, prefix)
+                    _attrs[qname] = a
+                    _attrsNS[(uri, localname)] = a
+                else:
+                    a = minidom.Attr(aname, EMPTY_NAMESPACE,
+                                     aname, EMPTY_PREFIX)
+                    _attrs[aname] = a
+                    _attrsNS[(EMPTY_NAMESPACE, aname)] = a
+                d = a.childNodes[0].__dict__
+                d['data'] = d['nodeValue'] = value
+                d = a.__dict__
+                d['ownerDocument'] = self.document
+                d['value'] = d['nodeValue'] = value
+                d['ownerElement'] = node
+
+    if __debug__:
+        # This only adds some asserts to the original
+        # end_element_handler(), so we only define this when -O is not
+        # used.  If changing one, be sure to check the other to see if
+        # it needs to be changed as well.
+        #
+        def end_element_handler(self, name):
+            curNode = self.curNode
+            if ' ' in name:
+                uri, localname, prefix, qname = _parse_ns_name(self, name)
+                assert (curNode.namespaceURI == uri
+                        and curNode.localName == localname
+                        and curNode.prefix == prefix), \
+                        "element stack messed up! (namespace)"
+            else:
+                assert curNode.nodeName == name, \
+                       "element stack messed up - bad nodeName"
+                assert curNode.namespaceURI == EMPTY_NAMESPACE, \
+                       "element stack messed up - bad namespaceURI"
+            self.curNode = curNode.parentNode
+            self._finish_end_element(curNode)
+
+
+class ExpatBuilderNS(Namespaces, ExpatBuilder):
+    """Document builder that supports namespaces."""
+
+    def reset(self):
+        ExpatBuilder.reset(self)
+        self._initNamespaces()
+
+
+class FragmentBuilderNS(Namespaces, FragmentBuilder):
+    """Fragment builder that supports namespaces."""
+
+    def reset(self):
+        FragmentBuilder.reset(self)
+        self._initNamespaces()
+
+    def _getNSattrs(self):
+        """Return string of namespace attributes from this element and
+        ancestors."""
+        # XXX This needs to be re-written to walk the ancestors of the
+        # context to build up the namespace information from
+        # declarations, elements, and attributes found in context.
+        # Otherwise we have to store a bunch more data on the DOM
+        # (though that *might* be more reliable -- not clear).
+        attrs = ""
+        context = self.context
+        L = []
+        while context:
+            if hasattr(context, '_ns_prefix_uri'):
+                for prefix, uri in context._ns_prefix_uri.items():
+                    # add every new NS decl from context to L and attrs string
+                    if prefix in L:
+                        continue
+                    L.append(prefix)
+                    if prefix:
+                        declname = "xmlns:" + prefix
+                    else:
+                        declname = "xmlns"
+                    if attrs:
+                        attrs = "%s\n    %s='%s'" % (attrs, declname, uri)
+                    else:
+                        attrs = " %s='%s'" % (declname, uri)
+            context = context.parentNode
+        return attrs
+
+
+class ParseEscape(Exception):
+    """Exception raised to short-circuit parsing in InternalSubsetExtractor."""
+    pass
+
+class InternalSubsetExtractor(ExpatBuilder):
+    """XML processor which can rip out the internal document type subset."""
+
+    subset = None
+
+    def getSubset(self):
+        """Return the internal subset as a string."""
+        return self.subset
+
+    def parseFile(self, file):
+        try:
+            ExpatBuilder.parseFile(self, file)
+        except ParseEscape:
+            pass
+
+    def parseString(self, string):
+        try:
+            ExpatBuilder.parseString(self, string)
+        except ParseEscape:
+            pass
+
+    def install(self, parser):
+        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
+        parser.StartElementHandler = self.start_element_handler
+
+    def start_doctype_decl_handler(self, name, publicId, systemId,
+                                   has_internal_subset):
+        if has_internal_subset:
+            parser = self.getParser()
+            self.subset = []
+            parser.DefaultHandler = self.subset.append
+            parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler
+        else:
+            raise ParseEscape()
+
+    def end_doctype_decl_handler(self):
+        s = ''.join(self.subset).replace('\r\n', '\n').replace('\r', '\n')
+        self.subset = s
+        raise ParseEscape()
+
+    def start_element_handler(self, name, attrs):
+        raise ParseEscape()
+
+
+def parse(file, namespaces=True):
+    """Parse a document, returning the resulting Document node.
+
+    'file' may be either a file name or an open file object.
+    """
+    if namespaces:
+        builder = ExpatBuilderNS()
+    else:
+        builder = ExpatBuilder()
+
+    if isinstance(file, StringTypes):
+        fp = open(file, 'rb')
+        try:
+            result = builder.parseFile(fp)
+        finally:
+            fp.close()
+    else:
+        result = builder.parseFile(file)
+    return result
+
+
+def parseString(string, namespaces=True):
+    """Parse a document from a string, returning the resulting
+    Document node.
+    """
+    if namespaces:
+        builder = ExpatBuilderNS()
+    else:
+        builder = ExpatBuilder()
+    return builder.parseString(string)
+
+
+def parseFragment(file, context, namespaces=True):
+    """Parse a fragment of a document, given the context from which it
+    was originally extracted.  context should be the parent of the
+    node(s) which are in the fragment.
+
+    'file' may be either a file name or an open file object.
+    """
+    if namespaces:
+        builder = FragmentBuilderNS(context)
+    else:
+        builder = FragmentBuilder(context)
+
+    if isinstance(file, StringTypes):
+        fp = open(file, 'rb')
+        try:
+            result = builder.parseFile(fp)
+        finally:
+            fp.close()
+    else:
+        result = builder.parseFile(file)
+    return result
+
+
+def parseFragmentString(string, context, namespaces=True):
+    """Parse a fragment of a document from a string, given the context
+    from which it was originally extracted.  context should be the
+    parent of the node(s) which are in the fragment.
+    """
+    if namespaces:
+        builder = FragmentBuilderNS(context)
+    else:
+        builder = FragmentBuilder(context)
+    return builder.parseString(string)
+
+
+def makeBuilder(options):
+    """Create a builder based on an Options object."""
+    if options.namespaces:
+        return ExpatBuilderNS(options)
+    else:
+        return ExpatBuilder(options)

plugins/Jython/Lib/xml/dom/minicompat.py

@@ -0,0 +1,110 @@
+"""Python version compatibility support for minidom."""
+
+# This module should only be imported using "import *".
+#
+# The following names are defined:
+#
+#   NodeList      -- lightest possible NodeList implementation
+#
+#   EmptyNodeList -- lightest possible NodeList that is guaranteed to
+#                    remain empty (immutable)
+#
+#   StringTypes   -- tuple of defined string types
+#
+#   defproperty   -- function used in conjunction with GetattrMagic;
+#                    using these together is needed to make them work
+#                    as efficiently as possible in both Python 2.2+
+#                    and older versions.  For example:
+#
+#                        class MyClass(GetattrMagic):
+#                            def _get_myattr(self):
+#                                return something
+#
+#                        defproperty(MyClass, "myattr",
+#                                    "return some value")
+#
+#                    For Python 2.2 and newer, this will construct a
+#                    property object on the class, which avoids
+#                    needing to override __getattr__().  It will only
+#                    work for read-only attributes.
+#
+#                    For older versions of Python, inheriting from
+#                    GetattrMagic will use the traditional
+#                    __getattr__() hackery to achieve the same effect,
+#                    but less efficiently.
+#
+#                    defproperty() should be used for each version of
+#                    the relevant _get_<property>() function.
+
+__all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"]
+
+import xml.dom
+
+try:
+    unicode
+except NameError:
+    StringTypes = type(''),
+else:
+    StringTypes = type(''), type(unicode(''))
+
+
+class NodeList(list):
+    __slots__ = ()
+
+    def item(self, index):
+        if 0 <= index < len(self):
+            return self[index]
+
+    def _get_length(self):
+        return len(self)
+
+    def _set_length(self, value):
+        raise xml.dom.NoModificationAllowedErr(
+            "attempt to modify read-only attribute 'length'")
+
+    length = property(_get_length, _set_length,
+                      doc="The number of nodes in the NodeList.")
+
+    # For backward compatibility
+    def __setstate__(self, state):
+        if state is None:
+            state = []
+        self[:] = state
+
+
+class EmptyNodeList(tuple):
+    __slots__ = ()
+
+    def __add__(self, other):
+        NL = NodeList()
+        NL.extend(other)
+        return NL
+
+    def __radd__(self, other):
+        NL = NodeList()
+        NL.extend(other)
+        return NL
+
+    def item(self, index):
+        return None
+
+    def _get_length(self):
+        return 0
+
+    def _set_length(self, value):
+        raise xml.dom.NoModificationAllowedErr(
+            "attempt to modify read-only attribute 'length'")
+
+    length = property(_get_length, _set_length,
+                      doc="The number of nodes in the NodeList.")
+
+
+def defproperty(klass, name, doc):
+    get = getattr(klass, ("_get_" + name)).im_func
+    def set(self, value, name=name):
+        raise xml.dom.NoModificationAllowedErr(
+            "attempt to modify read-only attribute " + repr(name))
+    assert not hasattr(klass, "_set_" + name), \
+           "expected not to find _set_" + name
+    prop = property(get, set, doc=doc)
+    setattr(klass, name, prop)

plugins/Jython/Lib/xml/dom/pulldom.py

@@ -0,0 +1,352 @@
+import xml.sax
+import xml.sax.handler
+import types
+
+try:
+    _StringTypes = [types.StringType, types.UnicodeType]
+except AttributeError:
+    _StringTypes = [types.StringType]
+
+START_ELEMENT = "START_ELEMENT"
+END_ELEMENT = "END_ELEMENT"
+COMMENT = "COMMENT"
+START_DOCUMENT = "START_DOCUMENT"
+END_DOCUMENT = "END_DOCUMENT"
+PROCESSING_INSTRUCTION = "PROCESSING_INSTRUCTION"
+IGNORABLE_WHITESPACE = "IGNORABLE_WHITESPACE"
+CHARACTERS = "CHARACTERS"
+
+class PullDOM(xml.sax.ContentHandler):
+    _locator = None
+    document = None
+
+    def __init__(self, documentFactory=None):
+        from xml.dom import XML_NAMESPACE
+        self.documentFactory = documentFactory
+        self.firstEvent = [None, None]
+        self.lastEvent = self.firstEvent
+        self.elementStack = []
+        self.push = self.elementStack.append
+        try:
+            self.pop = self.elementStack.pop
+        except AttributeError:
+            # use class' pop instead
+            pass
+        self._ns_contexts = [{XML_NAMESPACE:'xml'}] # contains uri -> prefix dicts
+        self._current_context = self._ns_contexts[-1]
+        self.pending_events = []
+
+    def pop(self):
+        result = self.elementStack[-1]
+        del self.elementStack[-1]
+        return result
+
+    def setDocumentLocator(self, locator):
+        self._locator = locator
+
+    def startPrefixMapping(self, prefix, uri):
+        if not hasattr(self, '_xmlns_attrs'):
+            self._xmlns_attrs = []
+        self._xmlns_attrs.append((prefix or 'xmlns', uri))
+        self._ns_contexts.append(self._current_context.copy())
+        self._current_context[uri] = prefix or None
+
+    def endPrefixMapping(self, prefix):
+        self._current_context = self._ns_contexts.pop()
+
+    def startElementNS(self, name, tagName , attrs):
+        uri, localname = name
+        if uri:
+            # When using namespaces, the reader may or may not
+            # provide us with the original name. If not, create
+            # *a* valid tagName from the current context.
+            if tagName is None:
+                prefix = self._current_context[uri]
+                if prefix:
+                    tagName = prefix + ":" + localname
+                else:
+                    tagName = localname
+            if self.document:
+                node = self.document.createElementNS(uri, tagName)
+            else:
+                node = self.buildDocument(uri, tagName)
+        else:
+            # When the tagname is not prefixed, it just appears as
+            # localname
+            if self.document:
+                node = self.document.createElement(localname)
+            else:
+                node = self.buildDocument(None, localname)
+
+        # Retrieve xml namespace declaration attributes.
+        xmlns_uri = 'http://www.w3.org/2000/xmlns/'
+        xmlns_attrs = getattr(self, '_xmlns_attrs', None)
+        if xmlns_attrs is not None:
+            for aname, value in xmlns_attrs:
+                if aname == 'xmlns':
+                    qname = aname
+                else:
+                    qname = 'xmlns:' + aname
+                attr = self.document.createAttributeNS(xmlns_uri, qname)
+                attr.value = value
+                node.setAttributeNodeNS(attr)
+            self._xmlns_attrs = []
+        for aname,value in attrs.items():
+            a_uri, a_localname = aname
+            if a_uri:
+                prefix = self._current_context[a_uri]
+                if prefix:
+                    qname = prefix + ":" + a_localname
+                else:
+                    qname = a_localname
+                attr = self.document.createAttributeNS(a_uri, qname)
+                node.setAttributeNodeNS(attr)
+            else:
+                attr = self.document.createAttribute(a_localname)
+                node.setAttributeNode(attr)
+            attr.value = value
+
+        self.lastEvent[1] = [(START_ELEMENT, node), None]
+        self.lastEvent = self.lastEvent[1]
+        self.push(node)
+
+    def endElementNS(self, name, tagName):
+        self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]
+        self.lastEvent = self.lastEvent[1]
+
+    def startElement(self, name, attrs):
+        if self.document:
+            node = self.document.createElement(name)
+        else:
+            node = self.buildDocument(None, name)
+
+        for aname,value in attrs.items():
+            attr = self.document.createAttribute(aname)
+            attr.value = value
+            node.setAttributeNode(attr)
+
+        self.lastEvent[1] = [(START_ELEMENT, node), None]
+        self.lastEvent = self.lastEvent[1]
+        self.push(node)
+
+    def endElement(self, name):
+        self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]
+        self.lastEvent = self.lastEvent[1]
+
+    def comment(self, s):
+        if self.document:
+            node = self.document.createComment(s)
+            self.lastEvent[1] = [(COMMENT, node), None]
+            self.lastEvent = self.lastEvent[1]
+        else:
+            event = [(COMMENT, s), None]
+            self.pending_events.append(event)
+
+    def processingInstruction(self, target, data):
+        if self.document:
+            node = self.document.createProcessingInstruction(target, data)
+            self.lastEvent[1] = [(PROCESSING_INSTRUCTION, node), None]
+            self.lastEvent = self.lastEvent[1]
+        else:
+            event = [(PROCESSING_INSTRUCTION, target, data), None]
+            self.pending_events.append(event)
+
+    def ignorableWhitespace(self, chars):
+        node = self.document.createTextNode(chars)
+        self.lastEvent[1] = [(IGNORABLE_WHITESPACE, node), None]
+        self.lastEvent = self.lastEvent[1]
+
+    def characters(self, chars):
+        node = self.document.createTextNode(chars)
+        self.lastEvent[1] = [(CHARACTERS, node), None]
+        self.lastEvent = self.lastEvent[1]
+
+    def startDocument(self):
+        if self.documentFactory is None:
+            import xml.dom.minidom
+            self.documentFactory = xml.dom.minidom.Document.implementation
+
+    def buildDocument(self, uri, tagname):
+        # Can't do that in startDocument, since we need the tagname
+        # XXX: obtain DocumentType
+        node = self.documentFactory.createDocument(uri, tagname, None)
+        self.document = node
+        self.lastEvent[1] = [(START_DOCUMENT, node), None]
+        self.lastEvent = self.lastEvent[1]
+        self.push(node)
+        # Put everything we have seen so far into the document
+        for e in self.pending_events:
+            if e[0][0] == PROCESSING_INSTRUCTION:
+                _,target,data = e[0]
+                n = self.document.createProcessingInstruction(target, data)
+                e[0] = (PROCESSING_INSTRUCTION, n)
+            elif e[0][0] == COMMENT:
+                n = self.document.createComment(e[0][1])
+                e[0] = (COMMENT, n)
+            else:
+                raise AssertionError("Unknown pending event ",e[0][0])
+            self.lastEvent[1] = e
+            self.lastEvent = e
+        self.pending_events = None
+        return node.firstChild
+
+    def endDocument(self):
+        self.lastEvent[1] = [(END_DOCUMENT, self.document), None]
+        self.pop()
+
+    def clear(self):
+        "clear(): Explicitly release parsing structures"
+        self.document = None
+
+class ErrorHandler:
+    def warning(self, exception):
+        print exception
+    def error(self, exception):
+        raise exception
+    def fatalError(self, exception):
+        raise exception
+
+class DOMEventStream:
+    def __init__(self, stream, parser, bufsize):
+        self.stream = stream
+        self.parser = parser
+        self.bufsize = bufsize
+        if not hasattr(self.parser, 'feed'):
+            self.getEvent = self._slurp
+        self.reset()
+
+    def reset(self):
+        self.pulldom = PullDOM()
+        # This content handler relies on namespace support
+        self.parser.setFeature(xml.sax.handler.feature_namespaces, 1)
+        self.parser.setContentHandler(self.pulldom)
+
+    def __getitem__(self, pos):
+        rc = self.getEvent()
+        if rc:
+            return rc
+        raise IndexError
+
+    def next(self):
+        rc = self.getEvent()
+        if rc:
+            return rc
+        raise StopIteration
+
+    def __iter__(self):
+        return self
+
+    def expandNode(self, node):
+        event = self.getEvent()
+        parents = [node]
+        while event:
+            token, cur_node = event
+            if cur_node is node:
+                return
+            if token != END_ELEMENT:
+                parents[-1].appendChild(cur_node)
+            if token == START_ELEMENT:
+                parents.append(cur_node)
+            elif token == END_ELEMENT:
+                del parents[-1]
+            event = self.getEvent()
+
+    def getEvent(self):
+        # use IncrementalParser interface, so we get the desired
+        # pull effect
+        if not self.pulldom.firstEvent[1]:
+            self.pulldom.lastEvent = self.pulldom.firstEvent
+        while not self.pulldom.firstEvent[1]:
+            buf = self.stream.read(self.bufsize)
+            if not buf:
+                self.parser.close()
+                return None
+            self.parser.feed(buf)
+        rc = self.pulldom.firstEvent[1][0]
+        self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
+        return rc
+
+    def _slurp(self):
+        """ Fallback replacement for getEvent() using the
+            standard SAX2 interface, which means we slurp the
+            SAX events into memory (no performance gain, but
+            we are compatible to all SAX parsers).
+        """
+        self.parser.parse(self.stream)
+        self.getEvent = self._emit
+        return self._emit()
+
+    def _emit(self):
+        """ Fallback replacement for getEvent() that emits
+            the events that _slurp() read previously.
+        """
+        if self.pulldom.firstEvent[1] is None:
+            return None
+        rc = self.pulldom.firstEvent[1][0]
+        self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
+        return rc
+
+    def clear(self):
+        """clear(): Explicitly release parsing objects"""
+        self.pulldom.clear()
+        del self.pulldom
+        self.parser = None
+        self.stream = None
+
+class SAX2DOM(PullDOM):
+
+    def startElementNS(self, name, tagName , attrs):
+        PullDOM.startElementNS(self, name, tagName, attrs)
+        curNode = self.elementStack[-1]
+        parentNode = self.elementStack[-2]
+        parentNode.appendChild(curNode)
+
+    def startElement(self, name, attrs):
+        PullDOM.startElement(self, name, attrs)
+        curNode = self.elementStack[-1]
+        parentNode = self.elementStack[-2]
+        parentNode.appendChild(curNode)
+
+    def processingInstruction(self, target, data):
+        PullDOM.processingInstruction(self, target, data)
+        node = self.lastEvent[0][1]
+        parentNode = self.elementStack[-1]
+        parentNode.appendChild(node)
+
+    def ignorableWhitespace(self, chars):
+        PullDOM.ignorableWhitespace(self, chars)
+        node = self.lastEvent[0][1]
+        parentNode = self.elementStack[-1]
+        parentNode.appendChild(node)
+
+    def characters(self, chars):
+        PullDOM.characters(self, chars)
+        node = self.lastEvent[0][1]
+        parentNode = self.elementStack[-1]
+        parentNode.appendChild(node)
+
+
+default_bufsize = (2 ** 14) - 20
+
+def parse(stream_or_string, parser=None, bufsize=None):
+    if bufsize is None:
+        bufsize = default_bufsize
+    if type(stream_or_string) in _StringTypes:
+        stream = open(stream_or_string)
+    else:
+        stream = stream_or_string
+    if not parser:
+        parser = xml.sax.make_parser()
+    return DOMEventStream(stream, parser, bufsize)
+
+def parseString(string, parser=None):
+    try:
+        from cStringIO import StringIO
+    except ImportError:
+        from StringIO import StringIO
+
+    bufsize = len(string)
+    buf = StringIO(string)
+    if not parser:
+        parser = xml.sax.make_parser()
+    return DOMEventStream(buf, parser, bufsize)

plugins/Jython/Lib/xml/dom/xmlbuilder.py

@@ -0,0 +1,386 @@
+"""Implementation of the DOM Level 3 'LS-Load' feature."""
+
+import copy
+import xml.dom
+
+from xml.dom.NodeFilter import NodeFilter
+
+
+__all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"]
+
+
+class Options:
+    """Features object that has variables set for each DOMBuilder feature.
+
+    The DOMBuilder class uses an instance of this class to pass settings to
+    the ExpatBuilder class.
+    """
+
+    # Note that the DOMBuilder class in LoadSave constrains which of these
+    # values can be set using the DOM Level 3 LoadSave feature.
+
+    namespaces = 1
+    namespace_declarations = True
+    validation = False
+    external_parameter_entities = True
+    external_general_entities = True
+    external_dtd_subset = True
+    validate_if_schema = False
+    validate = False
+    datatype_normalization = False
+    create_entity_ref_nodes = True
+    entities = True
+    whitespace_in_element_content = True
+    cdata_sections = True
+    comments = True
+    charset_overrides_xml_encoding = True
+    infoset = False
+    supported_mediatypes_only = False
+
+    errorHandler = None
+    filter = None
+
+
+class DOMBuilder:
+    entityResolver = None
+    errorHandler = None
+    filter = None
+
+    ACTION_REPLACE = 1
+    ACTION_APPEND_AS_CHILDREN = 2
+    ACTION_INSERT_AFTER = 3
+    ACTION_INSERT_BEFORE = 4
+
+    _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN,
+                      ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)
+
+    def __init__(self):
+        self._options = Options()
+
+    def _get_entityResolver(self):
+        return self.entityResolver
+    def _set_entityResolver(self, entityResolver):
+        self.entityResolver = entityResolver
+
+    def _get_errorHandler(self):
+        return self.errorHandler
+    def _set_errorHandler(self, errorHandler):
+        self.errorHandler = errorHandler
+
+    def _get_filter(self):
+        return self.filter
+    def _set_filter(self, filter):
+        self.filter = filter
+
+    def setFeature(self, name, state):
+        if self.supportsFeature(name):
+            state = state and 1 or 0
+            try:
+                settings = self._settings[(_name_xform(name), state)]
+            except KeyError:
+                raise xml.dom.NotSupportedErr(
+                    "unsupported feature: %r" % (name,))
+            else:
+                for name, value in settings:
+                    setattr(self._options, name, value)
+        else:
+            raise xml.dom.NotFoundErr("unknown feature: " + repr(name))
+
+    def supportsFeature(self, name):
+        return hasattr(self._options, _name_xform(name))
+
+    def canSetFeature(self, name, state):
+        key = (_name_xform(name), state and 1 or 0)
+        return key in self._settings
+
+    # This dictionary maps from (feature,value) to a list of
+    # (option,value) pairs that should be set on the Options object.
+    # If a (feature,value) setting is not in this dictionary, it is
+    # not supported by the DOMBuilder.
+    #
+    _settings = {
+        ("namespace_declarations", 0): [
+            ("namespace_declarations", 0)],
+        ("namespace_declarations", 1): [
+            ("namespace_declarations", 1)],
+        ("validation", 0): [
+            ("validation", 0)],
+        ("external_general_entities", 0): [
+            ("external_general_entities", 0)],
+        ("external_general_entities", 1): [
+            ("external_general_entities", 1)],
+        ("external_parameter_entities", 0): [
+            ("external_parameter_entities", 0)],
+        ("external_parameter_entities", 1): [
+            ("external_parameter_entities", 1)],
+        ("validate_if_schema", 0): [
+            ("validate_if_schema", 0)],
+        ("create_entity_ref_nodes", 0): [
+            ("create_entity_ref_nodes", 0)],
+        ("create_entity_ref_nodes", 1): [
+            ("create_entity_ref_nodes", 1)],
+        ("entities", 0): [
+            ("create_entity_ref_nodes", 0),
+            ("entities", 0)],
+        ("entities", 1): [
+            ("entities", 1)],
+        ("whitespace_in_element_content", 0): [
+            ("whitespace_in_element_content", 0)],
+        ("whitespace_in_element_content", 1): [
+            ("whitespace_in_element_content", 1)],
+        ("cdata_sections", 0): [
+            ("cdata_sections", 0)],
+        ("cdata_sections", 1): [
+            ("cdata_sections", 1)],
+        ("comments", 0): [
+            ("comments", 0)],
+        ("comments", 1): [
+            ("comments", 1)],
+        ("charset_overrides_xml_encoding", 0): [
+            ("charset_overrides_xml_encoding", 0)],
+        ("charset_overrides_xml_encoding", 1): [
+            ("charset_overrides_xml_encoding", 1)],
+        ("infoset", 0): [],
+        ("infoset", 1): [
+            ("namespace_declarations", 0),
+            ("validate_if_schema", 0),
+            ("create_entity_ref_nodes", 0),
+            ("entities", 0),
+            ("cdata_sections", 0),
+            ("datatype_normalization", 1),
+            ("whitespace_in_element_content", 1),
+            ("comments", 1),
+            ("charset_overrides_xml_encoding", 1)],
+        ("supported_mediatypes_only", 0): [
+            ("supported_mediatypes_only", 0)],
+        ("namespaces", 0): [
+            ("namespaces", 0)],
+        ("namespaces", 1): [
+            ("namespaces", 1)],
+    }
+
+    def getFeature(self, name):
+        xname = _name_xform(name)
+        try:
+            return getattr(self._options, xname)
+        except AttributeError:
+            if name == "infoset":
+                options = self._options
+                return (options.datatype_normalization
+                        and options.whitespace_in_element_content
+                        and options.comments
+                        and options.charset_overrides_xml_encoding
+                        and not (options.namespace_declarations
+                                 or options.validate_if_schema
+                                 or options.create_entity_ref_nodes
+                                 or options.entities
+                                 or options.cdata_sections))
+            raise xml.dom.NotFoundErr("feature %s not known" % repr(name))
+
+    def parseURI(self, uri):
+        if self.entityResolver:
+            input = self.entityResolver.resolveEntity(None, uri)
+        else:
+            input = DOMEntityResolver().resolveEntity(None, uri)
+        return self.parse(input)
+
+    def parse(self, input):
+        options = copy.copy(self._options)
+        options.filter = self.filter
+        options.errorHandler = self.errorHandler
+        fp = input.byteStream
+        if fp is None and options.systemId:
+            import urllib2
+            fp = urllib2.urlopen(input.systemId)
+        return self._parse_bytestream(fp, options)
+
+    def parseWithContext(self, input, cnode, action):
+        if action not in self._legal_actions:
+            raise ValueError("not a legal action")
+        raise NotImplementedError("Haven't written this yet...")
+
+    def _parse_bytestream(self, stream, options):
+        import xml.dom.expatbuilder
+        builder = xml.dom.expatbuilder.makeBuilder(options)
+        return builder.parseFile(stream)
+
+
+def _name_xform(name):
+    return name.lower().replace('-', '_')
+
+
+class DOMEntityResolver(object):
+    __slots__ = '_opener',
+
+    def resolveEntity(self, publicId, systemId):
+        assert systemId is not None
+        source = DOMInputSource()
+        source.publicId = publicId
+        source.systemId = systemId
+        source.byteStream = self._get_opener().open(systemId)
+
+        # determine the encoding if the transport provided it
+        source.encoding = self._guess_media_encoding(source)
+
+        # determine the base URI is we can
+        import posixpath, urlparse
+        parts = urlparse.urlparse(systemId)
+        scheme, netloc, path, params, query, fragment = parts
+        # XXX should we check the scheme here as well?
+        if path and not path.endswith("/"):
+            path = posixpath.dirname(path) + "/"
+            parts = scheme, netloc, path, params, query, fragment
+            source.baseURI = urlparse.urlunparse(parts)
+
+        return source
+
+    def _get_opener(self):
+        try:
+            return self._opener
+        except AttributeError:
+            self._opener = self._create_opener()
+            return self._opener
+
+    def _create_opener(self):
+        import urllib2
+        return urllib2.build_opener()
+
+    def _guess_media_encoding(self, source):
+        info = source.byteStream.info()
+        if "Content-Type" in info:
+            for param in info.getplist():
+                if param.startswith("charset="):
+                    return param.split("=", 1)[1].lower()
+
+
+class DOMInputSource(object):
+    __slots__ = ('byteStream', 'characterStream', 'stringData',
+                 'encoding', 'publicId', 'systemId', 'baseURI')
+
+    def __init__(self):
+        self.byteStream = None
+        self.characterStream = None
+        self.stringData = None
+        self.encoding = None
+        self.publicId = None
+        self.systemId = None
+        self.baseURI = None
+
+    def _get_byteStream(self):
+        return self.byteStream
+    def _set_byteStream(self, byteStream):
+        self.byteStream = byteStream
+
+    def _get_characterStream(self):
+        return self.characterStream
+    def _set_characterStream(self, characterStream):
+        self.characterStream = characterStream
+
+    def _get_stringData(self):
+        return self.stringData
+    def _set_stringData(self, data):
+        self.stringData = data
+
+    def _get_encoding(self):
+        return self.encoding
+    def _set_encoding(self, encoding):
+        self.encoding = encoding
+
+    def _get_publicId(self):
+        return self.publicId
+    def _set_publicId(self, publicId):
+        self.publicId = publicId
+
+    def _get_systemId(self):
+        return self.systemId
+    def _set_systemId(self, systemId):
+        self.systemId = systemId
+
+    def _get_baseURI(self):
+        return self.baseURI
+    def _set_baseURI(self, uri):
+        self.baseURI = uri
+
+
+class DOMBuilderFilter:
+    """Element filter which can be used to tailor construction of
+    a DOM instance.
+    """
+
+    # There's really no need for this class; concrete implementations
+    # should just implement the endElement() and startElement()
+    # methods as appropriate.  Using this makes it easy to only
+    # implement one of them.
+
+    FILTER_ACCEPT = 1
+    FILTER_REJECT = 2
+    FILTER_SKIP = 3
+    FILTER_INTERRUPT = 4
+
+    whatToShow = NodeFilter.SHOW_ALL
+
+    def _get_whatToShow(self):
+        return self.whatToShow
+
+    def acceptNode(self, element):
+        return self.FILTER_ACCEPT
+
+    def startContainer(self, element):
+        return self.FILTER_ACCEPT
+
+del NodeFilter
+
+
+class DocumentLS:
+    """Mixin to create documents that conform to the load/save spec."""
+
+    async = False
+
+    def _get_async(self):
+        return False
+    def _set_async(self, async):
+        if async:
+            raise xml.dom.NotSupportedErr(
+                "asynchronous document loading is not supported")
+
+    def abort(self):
+        # What does it mean to "clear" a document?  Does the
+        # documentElement disappear?
+        raise NotImplementedError(
+            "haven't figured out what this means yet")
+
+    def load(self, uri):
+        raise NotImplementedError("haven't written this yet")
+
+    def loadXML(self, source):
+        raise NotImplementedError("haven't written this yet")
+
+    def saveXML(self, snode):
+        if snode is None:
+            snode = self
+        elif snode.ownerDocument is not self:
+            raise xml.dom.WrongDocumentErr()
+        return snode.toxml()
+
+
+class DOMImplementationLS:
+    MODE_SYNCHRONOUS = 1
+    MODE_ASYNCHRONOUS = 2
+
+    def createDOMBuilder(self, mode, schemaType):
+        if schemaType is not None:
+            raise xml.dom.NotSupportedErr(
+                "schemaType not yet supported")
+        if mode == self.MODE_SYNCHRONOUS:
+            return DOMBuilder()
+        if mode == self.MODE_ASYNCHRONOUS:
+            raise xml.dom.NotSupportedErr(
+                "asynchronous builders are not supported")
+        raise ValueError("unknown value for mode")
+
+    def createDOMWriter(self):
+        raise NotImplementedError(
+            "the writer interface hasn't been written yet!")
+
+    def createDOMInputSource(self):
+        return DOMInputSource()

plugins/Jython/Lib/xml/etree/ElementInclude.py

@@ -0,0 +1,142 @@
+#
+# ElementTree
+# $Id: ElementInclude.py 3375 2008-02-13 08:05:08Z fredrik $
+#
+# limited xinclude support for element trees
+#
+# history:
+# 2003-08-15 fl   created
+# 2003-11-14 fl   fixed default loader
+#
+# Copyright (c) 2003-2004 by Fredrik Lundh.  All rights reserved.
+#
+# fredrik@pythonware.com
+# http://www.pythonware.com
+#
+# --------------------------------------------------------------------
+# The ElementTree toolkit is
+#
+# Copyright (c) 1999-2008 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+
+# Licensed to PSF under a Contributor Agreement.
+# See http://www.python.org/psf/license for licensing details.
+
+##
+# Limited XInclude support for the ElementTree package.
+##
+
+import copy
+from . import ElementTree
+
+XINCLUDE = "{http://www.w3.org/2001/XInclude}"
+
+XINCLUDE_INCLUDE = XINCLUDE + "include"
+XINCLUDE_FALLBACK = XINCLUDE + "fallback"
+
+##
+# Fatal include error.
+
+class FatalIncludeError(SyntaxError):
+    pass
+
+##
+# Default loader.  This loader reads an included resource from disk.
+#
+# @param href Resource reference.
+# @param parse Parse mode.  Either "xml" or "text".
+# @param encoding Optional text encoding.
+# @return The expanded resource.  If the parse mode is "xml", this
+#    is an ElementTree instance.  If the parse mode is "text", this
+#    is a Unicode string.  If the loader fails, it can return None
+#    or raise an IOError exception.
+# @throws IOError If the loader fails to load the resource.
+
+def default_loader(href, parse, encoding=None):
+    with open(href) as file:
+        if parse == "xml":
+            data = ElementTree.parse(file).getroot()
+        else:
+            data = file.read()
+            if encoding:
+                data = data.decode(encoding)
+    return data
+
+##
+# Expand XInclude directives.
+#
+# @param elem Root element.
+# @param loader Optional resource loader.  If omitted, it defaults
+#     to {@link default_loader}.  If given, it should be a callable
+#     that implements the same interface as <b>default_loader</b>.
+# @throws FatalIncludeError If the function fails to include a given
+#     resource, or if the tree contains malformed XInclude elements.
+# @throws IOError If the function fails to load a given resource.
+
+def include(elem, loader=None):
+    if loader is None:
+        loader = default_loader
+    # look for xinclude elements
+    i = 0
+    while i < len(elem):
+        e = elem[i]
+        if e.tag == XINCLUDE_INCLUDE:
+            # process xinclude directive
+            href = e.get("href")
+            parse = e.get("parse", "xml")
+            if parse == "xml":
+                node = loader(href, parse)
+                if node is None:
+                    raise FatalIncludeError(
+                        "cannot load %r as %r" % (href, parse)
+                        )
+                node = copy.copy(node)
+                if e.tail:
+                    node.tail = (node.tail or "") + e.tail
+                elem[i] = node
+            elif parse == "text":
+                text = loader(href, parse, e.get("encoding"))
+                if text is None:
+                    raise FatalIncludeError(
+                        "cannot load %r as %r" % (href, parse)
+                        )
+                if i:
+                    node = elem[i-1]
+                    node.tail = (node.tail or "") + text + (e.tail or "")
+                else:
+                    elem.text = (elem.text or "") + text + (e.tail or "")
+                del elem[i]
+                continue
+            else:
+                raise FatalIncludeError(
+                    "unknown parse type in xi:include tag (%r)" % parse
+                )
+        elif e.tag == XINCLUDE_FALLBACK:
+            raise FatalIncludeError(
+                "xi:fallback tag must be child of xi:include (%r)" % e.tag
+                )
+        else:
+            include(e, loader)
+        i = i + 1

plugins/Jython/Lib/xml/etree/ElementPath.py

@@ -0,0 +1,303 @@
+#
+# ElementTree
+# $Id: ElementPath.py 3375 2008-02-13 08:05:08Z fredrik $
+#
+# limited xpath support for element trees
+#
+# history:
+# 2003-05-23 fl   created
+# 2003-05-28 fl   added support for // etc
+# 2003-08-27 fl   fixed parsing of periods in element names
+# 2007-09-10 fl   new selection engine
+# 2007-09-12 fl   fixed parent selector
+# 2007-09-13 fl   added iterfind; changed findall to return a list
+# 2007-11-30 fl   added namespaces support
+# 2009-10-30 fl   added child element value filter
+#
+# Copyright (c) 2003-2009 by Fredrik Lundh.  All rights reserved.
+#
+# fredrik@pythonware.com
+# http://www.pythonware.com
+#
+# --------------------------------------------------------------------
+# The ElementTree toolkit is
+#
+# Copyright (c) 1999-2009 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+
+# Licensed to PSF under a Contributor Agreement.
+# See http://www.python.org/psf/license for licensing details.
+
+##
+# Implementation module for XPath support.  There's usually no reason
+# to import this module directly; the <b>ElementTree</b> does this for
+# you, if needed.
+##
+
+import re
+
+xpath_tokenizer_re = re.compile(
+    "("
+    "'[^']*'|\"[^\"]*\"|"
+    "::|"
+    "//?|"
+    "\.\.|"
+    "\(\)|"
+    "[/.*:\[\]\(\)@=])|"
+    "((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|"
+    "\s+"
+    )
+
+def xpath_tokenizer(pattern, namespaces=None):
+    for token in xpath_tokenizer_re.findall(pattern):
+        tag = token[1]
+        if tag and tag[0] != "{" and ":" in tag:
+            try:
+                prefix, uri = tag.split(":", 1)
+                if not namespaces:
+                    raise KeyError
+                yield token[0], "{%s}%s" % (namespaces[prefix], uri)
+            except KeyError:
+                raise SyntaxError("prefix %r not found in prefix map" % prefix)
+        else:
+            yield token
+
+def get_parent_map(context):
+    parent_map = context.parent_map
+    if parent_map is None:
+        context.parent_map = parent_map = {}
+        for p in context.root.iter():
+            for e in p:
+                parent_map[e] = p
+    return parent_map
+
+def prepare_child(next, token):
+    tag = token[1]
+    def select(context, result):
+        for elem in result:
+            for e in elem:
+                if e.tag == tag:
+                    yield e
+    return select
+
+def prepare_star(next, token):
+    def select(context, result):
+        for elem in result:
+            for e in elem:
+                yield e
+    return select
+
+def prepare_self(next, token):
+    def select(context, result):
+        for elem in result:
+            yield elem
+    return select
+
+def prepare_descendant(next, token):
+    token = next()
+    if token[0] == "*":
+        tag = "*"
+    elif not token[0]:
+        tag = token[1]
+    else:
+        raise SyntaxError("invalid descendant")
+    def select(context, result):
+        for elem in result:
+            for e in elem.iter(tag):
+                if e is not elem:
+                    yield e
+    return select
+
+def prepare_parent(next, token):
+    def select(context, result):
+        # FIXME: raise error if .. is applied at toplevel?
+        parent_map = get_parent_map(context)
+        result_map = {}
+        for elem in result:
+            if elem in parent_map:
+                parent = parent_map[elem]
+                if parent not in result_map:
+                    result_map[parent] = None
+                    yield parent
+    return select
+
+def prepare_predicate(next, token):
+    # FIXME: replace with real parser!!! refs:
+    # http://effbot.org/zone/simple-iterator-parser.htm
+    # http://javascript.crockford.com/tdop/tdop.html
+    signature = []
+    predicate = []
+    while 1:
+        token = next()
+        if token[0] == "]":
+            break
+        if token[0] and token[0][:1] in "'\"":
+            token = "'", token[0][1:-1]
+        signature.append(token[0] or "-")
+        predicate.append(token[1])
+    signature = "".join(signature)
+    # use signature to determine predicate type
+    if signature == "@-":
+        # [@attribute] predicate
+        key = predicate[1]
+        def select(context, result):
+            for elem in result:
+                if elem.get(key) is not None:
+                    yield elem
+        return select
+    if signature == "@-='":
+        # [@attribute='value']
+        key = predicate[1]
+        value = predicate[-1]
+        def select(context, result):
+            for elem in result:
+                if elem.get(key) == value:
+                    yield elem
+        return select
+    if signature == "-" and not re.match("\d+$", predicate[0]):
+        # [tag]
+        tag = predicate[0]
+        def select(context, result):
+            for elem in result:
+                if elem.find(tag) is not None:
+                    yield elem
+        return select
+    if signature == "-='" and not re.match("\d+$", predicate[0]):
+        # [tag='value']
+        tag = predicate[0]
+        value = predicate[-1]
+        def select(context, result):
+            for elem in result:
+                for e in elem.findall(tag):
+                    if "".join(e.itertext()) == value:
+                        yield elem
+                        break
+        return select
+    if signature == "-" or signature == "-()" or signature == "-()-":
+        # [index] or [last()] or [last()-index]
+        if signature == "-":
+            index = int(predicate[0]) - 1
+        else:
+            if predicate[0] != "last":
+                raise SyntaxError("unsupported function")
+            if signature == "-()-":
+                try:
+                    index = int(predicate[2]) - 1
+                except ValueError:
+                    raise SyntaxError("unsupported expression")
+            else:
+                index = -1
+        def select(context, result):
+            parent_map = get_parent_map(context)
+            for elem in result:
+                try:
+                    parent = parent_map[elem]
+                    # FIXME: what if the selector is "*" ?
+                    elems = list(parent.findall(elem.tag))
+                    if elems[index] is elem:
+                        yield elem
+                except (IndexError, KeyError):
+                    pass
+        return select
+    raise SyntaxError("invalid predicate")
+
+ops = {
+    "": prepare_child,
+    "*": prepare_star,
+    ".": prepare_self,
+    "..": prepare_parent,
+    "//": prepare_descendant,
+    "[": prepare_predicate,
+    }
+
+_cache = {}
+
+class _SelectorContext:
+    parent_map = None
+    def __init__(self, root):
+        self.root = root
+
+# --------------------------------------------------------------------
+
+##
+# Generate all matching objects.
+
+def iterfind(elem, path, namespaces=None):
+    # compile selector pattern
+    if path[-1:] == "/":
+        path = path + "*" # implicit all (FIXME: keep this?)
+    try:
+        selector = _cache[path]
+    except KeyError:
+        if len(_cache) > 100:
+            _cache.clear()
+        if path[:1] == "/":
+            raise SyntaxError("cannot use absolute path on element")
+        next = iter(xpath_tokenizer(path, namespaces)).next
+        token = next()
+        selector = []
+        while 1:
+            try:
+                selector.append(ops[token[0]](next, token))
+            except StopIteration:
+                raise SyntaxError("invalid path")
+            try:
+                token = next()
+                if token[0] == "/":
+                    token = next()
+            except StopIteration:
+                break
+        _cache[path] = selector
+    # execute selector pattern
+    result = [elem]
+    context = _SelectorContext(elem)
+    for select in selector:
+        result = select(context, result)
+    return result
+
+##
+# Find first matching object.
+
+def find(elem, path, namespaces=None):
+    try:
+        return iterfind(elem, path, namespaces).next()
+    except StopIteration:
+        return None
+
+##
+# Find all matching objects.
+
+def findall(elem, path, namespaces=None):
+    return list(iterfind(elem, path, namespaces))
+
+##
+# Find text for first matching object.
+
+def findtext(elem, path, default=None, namespaces=None):
+    try:
+        elem = iterfind(elem, path, namespaces).next()
+        return elem.text or ""
+    except StopIteration:
+        return default

plugins/Jython/Lib/xml/etree/__init__.py

@@ -0,0 +1,33 @@
+# $Id: __init__.py 3375 2008-02-13 08:05:08Z fredrik $
+# elementtree package
+
+# --------------------------------------------------------------------
+# The ElementTree toolkit is
+#
+# Copyright (c) 1999-2008 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+
+# Licensed to PSF under a Contributor Agreement.
+# See http://www.python.org/psf/license for licensing details.

plugins/Jython/Lib/xml/etree/cElementTree.py

@@ -0,0 +1,11 @@
+# make an exact copy of ElementTree's namespace here to support even
+# private API usage
+from xml.etree.ElementTree import (
+    Comment, Element, ElementPath, ElementTree, PI, ParseError,
+    ProcessingInstruction, QName, SubElement, TreeBuilder, VERSION, XML, XMLID,
+    XMLParser, XMLTreeBuilder, _Element, _ElementInterface, _SimpleElementPath,
+    __all__, __doc__, __file__, __name__, __package__, _encode,
+    _escape_attrib, _escape_cdata, _namespace_map,
+    _raise_serialization_error, dump, fromstring, fromstringlist,
+    iselement, iterparse, parse, re, register_namespace, sys, tostring,
+    tostringlist)

plugins/Jython/Lib/xml/parsers/expat.py

@@ -0,0 +1,606 @@
+# coding: utf-8
+
+#------------------------------------------------------------------------------
+# Copyright (c) 2008 Sébastien Boisgérault
+#
+# 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.
+# -----------------------------------------------------------------------------
+
+__all__ = ["ExpatError", "ParserCreate", "XMLParserType", "error", "errors"]
+
+# Jython check
+import sys
+if not sys.platform.startswith('java'):
+    raise ImportError("this version of expat requires the jython interpreter")
+
+# Standard Python Library
+import re
+import types
+
+# Jython
+from org.python.core import Py
+from org.python.core.util import StringUtil
+from jarray import array
+
+# Java Standard Edition
+from java.io import ByteArrayInputStream
+from java.lang import String, StringBuilder
+from org.xml.sax import InputSource
+from org.xml.sax import SAXNotRecognizedException, SAXParseException
+from org.xml.sax.helpers import XMLReaderFactory
+from org.xml.sax.ext import DefaultHandler2
+
+# Xerces
+_mangled_xerces_parser_name = "org.python.apache.xerces.parsers.SAXParser"
+_xerces_parser_name = "org.apache.xerces.parsers.SAXParser"
+
+
+# @expat args registry
+_register = {}
+
+
+def ParserCreate(encoding=None, namespace_separator=None):
+    return XMLParser(encoding, namespace_separator)
+
+
+class XMLParser(object):
+
+    def __init__(self, encoding, namespace_separator):
+        self.encoding = encoding
+        self.CurrentLineNumber = 1
+        self.CurrentColumnNumber = 0
+        self._NextLineNumber = 1
+        self._NextColumnNumber = 0
+        self.ErrorLineNumber = -1
+        self.ErrorColumnNumber = -1
+        self.ErrorCode = None
+
+        if namespace_separator is None:
+            self.namespace_separator = namespace_separator
+        elif isinstance(namespace_separator, basestring):
+            self.namespace_separator = str(namespace_separator)
+            if len(self.namespace_separator) > 1:
+                error = ("namespace_separator must be at most one character, "
+                         "omitted, or None")
+                raise ValueError(error)
+        else:
+            error = ("ParserCreate() argument 2 must be string or None, "
+                     "not %s" % type(namespace_separator).__name__)
+            raise TypeError(error)
+
+        # See http://bugs.jython.org/issue1537
+        try:
+            self._reader = XMLReaderFactory.createXMLReader(_mangled_xerces_parser_name)
+        except:
+            self._reader = XMLReaderFactory.createXMLReader(_xerces_parser_name)
+
+        if self.namespace_separator is None:
+            try:
+                feature = "http://xml.org/sax/features/namespaces"
+                self._reader.setFeature(feature, False)
+            except SAXNotRecognizedException:
+                error = ("namespace support cannot be disabled; "
+                         "set namespace_separator to a string of length 1.")
+                raise ValueError(error)
+
+        self._base = None
+        self._buffer_text = True
+        self._returns_unicode = True
+
+        self._data = StringBuilder()
+
+        self._handler = XMLEventHandler(self)
+        self._reader.setContentHandler(self._handler)
+        self._reader.setErrorHandler(self._handler)
+        self._reader.setDTDHandler(self._handler)
+        self._reader.setEntityResolver(self._handler)
+
+        sax_properties = ("lexical-handler", "declaration-handler")
+        for name in sax_properties:
+            try:
+                name = "http://xml.org/sax/properties/" + name
+                self._reader.setProperty(name, self._handler)
+            except SAXNotRecognizedException:
+                error = "can't set property %r" % name
+                raise NotImplementedError(error)
+
+        apache_features = (("nonvalidating/load-external-dtd", False),)
+        for name, value in apache_features:
+            try:
+                name = "http://apache.org/xml/features/" + name
+                self._reader.setFeature(name, value)
+            except SAXNotRecognizedException:
+                error = "can't set feature %r" % name
+                raise NotImplementedError(error)
+
+        # experimental
+        #f = "http://xml.org/sax/features/external-general-entities"
+        f = "http://xml.org/sax/features/external-parameter-entities"
+        #self._reader.setFeature(f, False)
+
+        # check
+        f = "http://xml.org/sax/features/use-entity-resolver2"
+        assert self._reader.getFeature(f)
+
+    def GetBase(self):
+        return self._base
+
+    def SetBase(self, base):
+        self._base = base
+
+    def _error(self, value=None):
+        raise AttributeError("'XMLParser' has no such attribute")
+
+    def _get_buffer_text(self):
+        return self._buffer_text
+
+    def _set_buffer_text(self, value):
+        self._buffer_text = bool(value)
+
+    def _get_returns_unicode(self):
+        return bool(self._returns_unicode)
+
+    def _set_returns_unicode(self, value):
+        self._returns_unicode = value
+
+    # 'ordered' and 'specified' attributes are not supported
+    ordered_attributes = property(_error, _error)
+    specified_attributes = property(_error, _error)
+    # any setting is allowed, but it won't make a difference
+    buffer_text = property(_get_buffer_text, _set_buffer_text)
+    # non-significant read-only values
+    buffer_used = property(lambda self: None)
+    buffer_size = property(lambda self: None)
+    # 'returns_unicode' attribute is properly supported
+    returns_unicode = property(_get_returns_unicode, _set_returns_unicode)
+
+    def _expat_error(self, sax_error):
+        sax_message = sax_error.getMessage()
+        pattern = 'The entity ".*" was referenced, but not declared\.'
+        if re.match(pattern, sax_message):
+            expat_message = "undefined entity: line %s, column %s" % \
+                            (self.ErrorLineNumber, self.ErrorColumnNumber)
+        else:
+            expat_message = sax_message
+        error = ExpatError(expat_message)
+        error.lineno = self.ErrorLineNumber
+        error.offset = self.ErrorColumnNumber
+        error.code = self.ErrorCode
+        return error
+
+    def Parse(self, data, isfinal=False):
+        # The 'data' argument should be an encoded text: a str instance that
+        # represents an array of bytes. If instead it is a unicode string,
+        # only the us-ascii range is considered safe enough to be silently
+        # converted.
+        if isinstance(data, unicode):
+            data = data.encode(sys.getdefaultencoding())
+
+        self._data.append(data)
+
+        if isfinal:
+            bytes = StringUtil.toBytes(self._data.toString())
+            byte_stream = ByteArrayInputStream(bytes)
+            source = InputSource(byte_stream)
+            if self.encoding is not None:
+                source.setEncoding(self.encoding)
+            try:
+                self._reader.parse(source)
+            except SAXParseException, sax_error:
+                # Experiments tend to show that the '_Next*' parser locations
+                # match more closely expat behavior than the 'Current*' or sax
+                # error locations.
+                self.ErrorLineNumber = self._NextLineNumber
+                self.ErrorColumnNumber = self._NextColumnNumber
+                self.ErrorCode = None
+                raise self._expat_error(sax_error)
+            return 1
+
+    def ParseFile(self, file):
+        # TODO: pseudo-buffering if a read without argument is not supported.
+        #       document parse / parsefile usage.
+        return self.Parse(file.read(), isfinal=True)
+
+
+XMLParserType = XMLParser
+
+
+def _encode(arg, encoding):
+    if isinstance(arg, unicode):
+        return arg.encode(encoding)
+    else:
+        if isinstance(arg, dict):
+            iterator = arg.iteritems()
+        else:
+            iterator = iter(arg)
+        return type(arg)(_encode(_arg, encoding) for _arg in iterator)
+
+
+def expat(callback=None, guard=True, force=False, returns=None):
+    def _expat(method):
+        name = method.__name__
+        context = id(sys._getframe(1))
+        key = name, context
+        append = _register.setdefault(key, []).append
+        append((method, callback, guard, force, returns))
+
+        def new_method(*args):
+            self = args[0]
+            parser = self.parser
+            self._update_location(event=name) # bug if multiple method def
+            for (method, callback, guard, force, returns) in _register[key]:
+                if guard not in (True, False):
+                    guard = getattr(self, guard)
+                _callback = callback and guard and \
+                            getattr(parser, callback, None)
+                if _callback or force:
+                    results = method(*args)
+                    if _callback:
+                        if not isinstance(results, tuple):
+                            results = (results,)
+                        if not parser.returns_unicode:
+                            results = _encode(results, "utf-8")
+                        _callback(*results)
+                    return returns
+
+        new_method.__name__ = name
+        #new_method.__doc__ = method.__doc__ # what to do with multiple docs ?
+        return new_method
+    return _expat
+
+
+class XMLEventHandler(DefaultHandler2):
+
+    def __init__(self, parser):
+        self.parser = parser
+        self._tags = {}
+        self.not_in_dtd = True
+        self._entity = {}
+        self._previous_event = None
+
+    # --- Helpers -------------------------------------------------------------
+
+    def _intern(self, tag):
+        return self._tags.setdefault(tag, tag)
+
+    def _qualify(self, local_name, qname, namespace=None):
+        namespace_separator = self.parser.namespace_separator
+        if namespace_separator is None:
+            return qname
+        if not namespace:
+            return local_name
+        else:
+            return namespace + namespace_separator + local_name
+
+    def _char_slice_to_unicode(self, characters, start, length):
+        """Convert a char[] slice to a PyUnicode instance"""
+        text = Py.newUnicode(String(characters[start:start + length]))
+        return text
+
+    def _expat_content_model(self, name, model_):
+        # TODO : implement a model parser
+        return (name, model_) # does not fit expat conventions
+
+    def _update_location(self, event=None):
+        parser = self.parser
+        locator = self._locator
+
+        # ugly hack that takes care of a xerces-specific (?) locator issue:
+        # locate start and end elements at the '<' instead of the first tag
+        # type character.
+        if event == "startElement" and self._previous_event == "characters":
+            parser._NextColumnNumber = max(parser._NextColumnNumber - 1, 0)
+        if event == "endElement" and self._previous_event == "characters":
+            parser._NextColumnNumber = max(parser._NextColumnNumber - 2, 0)
+        # TODO: use the same trick to report accurate error locations ?
+
+        parser.CurrentLineNumber = parser._NextLineNumber
+        parser.CurrentColumnNumber = parser._NextColumnNumber
+        parser._NextLineNumber = locator.getLineNumber()
+        parser._NextColumnNumber = locator.getColumnNumber() - 1
+
+        self._previous_event = event
+
+    # --- ContentHandler Interface --------------------------------------------
+
+    @expat("ProcessingInstructionHandler")
+    def processingInstruction(self, target, data):
+        return target, data
+
+    @expat("StartElementHandler")
+    def startElement(self, namespace, local_name, qname, attributes):
+        tag = self._qualify(local_name, qname, namespace)
+        attribs = {}
+        length = attributes.getLength()
+        for index in range(length):
+            local_name = attributes.getLocalName(index)
+            qname = attributes.getQName(index)
+            namespace = attributes.getURI(index)
+            name = self._qualify(local_name, qname, namespace)
+            value = attributes.getValue(index)
+            attribs[name] = value
+        return self._intern(tag), attribs
+
+    @expat("EndElementHandler")
+    def endElement(self, namespace, local_name, qname):
+        return self._intern(self._qualify(local_name, qname, namespace))
+
+    @expat("CharacterDataHandler")
+    def characters(self, characters, start, length):
+        return self._char_slice_to_unicode(characters, start, length)
+
+    @expat("DefaultHandlerExpand")
+    def characters(self, characters, start, length):
+        return self._char_slice_to_unicode(characters, start, length)
+
+    @expat("DefaultHandler")
+    def characters(self, characters, start, length):
+        # TODO: make a helper function here
+        if self._entity["location"] == (self.parser.CurrentLineNumber,
+                                        self.parser.CurrentColumnNumber):
+            return "&%s;" % self._entity["name"]
+        else:
+            return self._char_slice_to_unicode(characters, start, length)
+
+    @expat("StartNamespaceDeclHandler")
+    def startPrefixMapping(self, prefix, uri):
+        return prefix, uri
+
+    @expat("EndNamespaceDeclHandler")
+    def endPrefixMapping(self, prefix):
+        return prefix
+
+    empty_source = InputSource(ByteArrayInputStream(array([], "b")))
+
+    @expat("ExternalEntityRefHandler", guard="not_in_dtd",
+                                       returns=empty_source)
+    def resolveEntity(self, name, publicId, baseURI, systemId):
+        context = name # wrong. see expat headers documentation.
+        base = self.parser.GetBase()
+        return context, base, systemId, publicId
+
+    @expat("DefaultHandlerExpand", guard="not_in_dtd",
+                                   returns=empty_source)
+    def resolveEntity(self, name, publicId, baseURI, systemId):
+        return "&%s;" % name
+
+    @expat("DefaultHandler", guard="not_in_dtd",
+                             returns=empty_source)
+    def resolveEntity(self, name, publicId, baseURI, systemId):
+        return "&%s;" % name
+
+    @expat(force=True, returns=empty_source)
+    def resolveEntity(self, name, publicId, baseURI, systemId):
+        pass
+
+    def setDocumentLocator(self, locator):
+        self._locator = locator
+
+    def skippedEntity(self, name):
+        error = ExpatError()
+        error.lineno = self.ErrorLineNumber = self.parser._NextLineNumber
+        error.offset = self.ErrorColumnNumber = self.parser._NextColumnNumber
+        error.code = self.ErrorCode = None
+        message = "undefined entity &%s;: line %s, column %s"
+        message = message % (name, error.lineno, error.offset)
+        error.__init__(message)
+        raise error
+
+    # --- LexicalHandler Interface --------------------------------------------
+
+    @expat("CommentHandler")
+    def comment(self, characters, start, length):
+        return self._char_slice_to_unicode(characters, start, length)
+
+    @expat("StartCdataSectionHandler")
+    def startCDATA(self):
+        return ()
+
+    @expat("EndCdataSectionHandler")
+    def endCDATA(self):
+        return ()
+
+    @expat("StartDoctypeDeclHandler", force=True)
+    def startDTD(self, name, publicId, systemId):
+        self.not_in_dtd = False
+        has_internal_subset = 0 # don't know this ...
+        return name, systemId, publicId, has_internal_subset
+
+    @expat("EndDoctypeDeclHandler", force=True)
+    def endDTD(self):
+        self.not_in_dtd = True
+
+    def startEntity(self, name):
+        self._entity = {}
+        self._entity["location"] = (self.parser._NextLineNumber,
+                                    self.parser._NextColumnNumber)
+        self._entity["name"] = name
+
+    def endEntity(self, name):
+        pass
+
+    # --- DTDHandler Interface ------------------------------------------------
+
+    @expat("NotationDeclHandler")
+    def notationDecl(self, name, publicId, systemId):
+        base = self.parser.GetBase()
+        return name, base, systemId, publicId
+
+    @expat("UnparsedEntityDeclHandler") # deprecated
+    def unparsedEntityDecl(self, name, publicId, systemId, notationName):
+        base = self.parser.GetBase()
+        return name, base, systemId, publicId, notationName
+
+    # --- DeclHandler Interface -----------------------------------------------
+
+    @expat("AttlistDeclHandler")
+    def attributeDecl(self, eName, aName, type, mode, value):
+        # TODO: adapt mode, required, etc.
+        required = False
+        return eName, aName, type, value, required
+
+    @expat("ElementDeclHandler")
+    def elementDecl(self, name, model):
+        return self._expat_content_model(name, model)
+
+    @expat("EntityDeclHandler")
+    def externalEntityDecl(self, name, publicId, systemId):
+        base = self.parser.GetBase()
+        value = None
+        is_parameter_entity = None
+        notation_name = None
+        return (name, is_parameter_entity, value, base, systemId, publicId,
+                notation_name)
+
+    @expat("EntityDeclHandler")
+    def internalEntityDecl(self, name, value):
+        base = self.parser.GetBase()
+        is_parameter_entity = None
+        notation_name = None
+        systemId, publicId = None, None
+        return (name, is_parameter_entity, value, base, systemId, publicId,
+                notation_name)
+
+
+def _init_model():
+    global model
+    model = types.ModuleType("pyexpat.model")
+    model.__doc__ = "Constants used to interpret content model information."
+    quantifiers = "NONE, OPT, REP, PLUS"
+    for i, quantifier in enumerate(quantifiers.split(", ")):
+        setattr(model, "XML_CQUANT_" + quantifier, i)
+    types_ = "EMPTY, ANY, MIXED, NAME, CHOICE, SEQ"
+    for i, type_ in enumerate(types_.split(", ")):
+        setattr(model, "XML_CTYPE_" + type_, i+1)
+
+_init_model()
+del _init_model
+
+
+class ExpatError(Exception):
+    pass
+
+
+error = ExpatError
+
+
+def _init_error_strings():
+    global ErrorString
+    error_strings = (
+        None,
+        "out of memory",
+        "syntax error",
+        "no element found",
+        "not well-formed (invalid token)",
+        "unclosed token",
+        "partial character",
+        "mismatched tag",
+        "duplicate attribute",
+        "junk after document element",
+        "illegal parameter entity reference",
+        "undefined entity",
+        "recursive entity reference",
+        "asynchronous entity",
+        "reference to invalid character number",
+        "reference to binary entity",
+        "reference to external entity in attribute",
+        "XML or text declaration not at start of entity",
+        "unknown encoding",
+        "encoding specified in XML declaration is incorrect",
+        "unclosed CDATA section",
+        "error in processing external entity reference",
+        "document is not standalone",
+        "unexpected parser state - please send a bug report",
+        "entity declared in parameter entity",
+        "requested feature requires XML_DTD support in Expat",
+        "cannot change setting once parsing has begun",
+        "unbound prefix",
+        "must not undeclare prefix",
+        "incomplete markup in parameter entity",
+        "XML declaration not well-formed",
+        "text declaration not well-formed",
+        "illegal character(s) in public id",
+        "parser suspended",
+        "parser not suspended",
+        "parsing aborted",
+        "parsing finished",
+        "cannot suspend in external parameter entity")
+    def ErrorString(code):
+        try:
+            return error_strings[code]
+        except IndexError:
+            return None
+
+_init_error_strings()
+del _init_error_strings
+
+
+def _init_errors():
+    global errors
+
+    errors = types.ModuleType("pyexpat.errors")
+    errors.__doc__ = "Constants used to describe error conditions."
+
+    error_names = """
+    XML_ERROR_NONE
+    XML_ERROR_NONE,
+    XML_ERROR_NO_MEMORY,
+    XML_ERROR_SYNTAX,
+    XML_ERROR_NO_ELEMENTS,
+    XML_ERROR_INVALID_TOKEN,
+    XML_ERROR_UNCLOSED_TOKEN,
+    XML_ERROR_PARTIAL_CHAR,
+    XML_ERROR_TAG_MISMATCH,
+    XML_ERROR_DUPLICATE_ATTRIBUTE,
+    XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+    XML_ERROR_PARAM_ENTITY_REF,
+    XML_ERROR_UNDEFINED_ENTITY,
+    XML_ERROR_RECURSIVE_ENTITY_REF,
+    XML_ERROR_ASYNC_ENTITY,
+    XML_ERROR_BAD_CHAR_REF,
+    XML_ERROR_BINARY_ENTITY_REF,
+    XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+    XML_ERROR_MISPLACED_XML_PI,
+    XML_ERROR_UNKNOWN_ENCODING,
+    XML_ERROR_INCORRECT_ENCODING,
+    XML_ERROR_UNCLOSED_CDATA_SECTION,
+    XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+    XML_ERROR_NOT_STANDALONE,
+    XML_ERROR_UNEXPECTED_STATE,
+    XML_ERROR_ENTITY_DECLARED_IN_PE,
+    XML_ERROR_FEATURE_REQUIRES_XML_DTD,
+    XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
+    XML_ERROR_UNBOUND_PREFIX,
+    XML_ERROR_UNDECLARING_PREFIX,
+    XML_ERROR_INCOMPLETE_PE,
+    XML_ERROR_XML_DECL,
+    XML_ERROR_TEXT_DECL,
+    XML_ERROR_PUBLICID,
+    XML_ERROR_SUSPENDED,
+    XML_ERROR_NOT_SUSPENDED,
+    XML_ERROR_ABORTED,
+    XML_ERROR_FINISHED,
+    XML_ERROR_SUSPEND_PE
+    """
+    error_names = [name.strip() for name in error_names.split(',')]
+    for i, name in enumerate(error_names[1:]):
+        setattr(errors, name, ErrorString(i+1))
+
+_init_errors()
+del _init_errors

plugins/Jython/Lib/xml/sax/__init__.py

@@ -0,0 +1,102 @@
+"""Simple API for XML (SAX) implementation for Python.
+
+This module provides an implementation of the SAX 2 interface;
+information about the Java version of the interface can be found at
+http://www.megginson.com/SAX/.  The Python version of the interface is
+documented at <...>.
+
+This package contains the following modules:
+
+handler -- Base classes and constants which define the SAX 2 API for
+           the 'client-side' of SAX for Python.
+
+saxutils -- Implementation of the convenience classes commonly used to
+            work with SAX.
+
+xmlreader -- Base classes and constants which define the SAX 2 API for
+             the parsers used with SAX for Python.
+
+drivers2 -- Contains the driver for that wraps a Java sax implementation in python
+            objects.
+"""
+
+from xmlreader import InputSource
+from handler import ContentHandler, ErrorHandler
+from _exceptions import SAXException, SAXNotRecognizedException, \
+                        SAXParseException, SAXNotSupportedException, \
+                        SAXReaderNotAvailable
+
+
+def parse(source, handler, errorHandler=ErrorHandler()):
+    parser = make_parser()
+    parser.setContentHandler(handler)
+    parser.setErrorHandler(errorHandler)
+    parser.parse(source)
+
+def parseString(string, handler, errorHandler=ErrorHandler()):
+    try:
+        from cStringIO import StringIO
+    except ImportError:
+        from StringIO import StringIO
+
+    if errorHandler is None:
+        errorHandler = ErrorHandler()
+    parser = make_parser()
+    parser.setContentHandler(handler)
+    parser.setErrorHandler(errorHandler)
+
+    inpsrc = InputSource()
+    inpsrc.setByteStream(StringIO(string))
+    parser.parse(inpsrc)
+
+# this is the parser list used by the make_parser function if no
+# alternatives are given as parameters to the function
+
+default_parser_list = ["xml.sax.drivers2.drv_javasax"]
+
+# tell modulefinder that importing sax potentially imports expatreader
+_false = 0
+if _false:
+    import xml.sax.drivers2.drv_javasax
+
+import os, sys
+if os.environ.has_key("PY_SAX_PARSER"):
+    default_parser_list = os.environ["PY_SAX_PARSER"].split(",")
+del os
+
+_key = "python.xml.sax.parser"
+if sys.platform[:4] == "java" and sys.registry.containsKey(_key):
+    default_parser_list = sys.registry.getProperty(_key).split(",")
+
+
+def make_parser(parser_list = []):
+    """Creates and returns a SAX parser.
+
+    Creates the first parser it is able to instantiate of the ones
+    given in the list created by doing parser_list +
+    default_parser_list.  The lists must contain the names of Python
+    modules containing both a SAX parser and a create_parser function."""
+
+    for parser_name in parser_list + default_parser_list:
+        try:
+            return _create_parser(parser_name)
+        except ImportError,e:
+            import sys
+            if sys.modules.has_key(parser_name):
+                # The parser module was found, but importing it
+                # failed unexpectedly, pass this exception through
+                raise
+        except SAXReaderNotAvailable:
+            # The parser module detected that it won't work properly,
+            # so try the next one
+            pass
+
+    raise SAXReaderNotAvailable("No parsers found", None)
+
+# --- Internal utility methods used by make_parser
+
+def _create_parser(parser_name):
+    drv_module = __import__(parser_name,{},{},['create_parser'])
+    return drv_module.create_parser()
+
+del sys

plugins/Jython/Lib/xml/sax/_exceptions.py

@@ -0,0 +1,127 @@
+"""Different kinds of SAX Exceptions"""
+
+# ===== SAXEXCEPTION =====
+
+class SAXException(Exception):
+    """Encapsulate an XML error or warning. This class can contain
+    basic error or warning information from either the XML parser or
+    the application: you can subclass it to provide additional
+    functionality, or to add localization. Note that although you will
+    receive a SAXException as the argument to the handlers in the
+    ErrorHandler interface, you are not actually required to throw
+    the exception; instead, you can simply read the information in
+    it."""
+
+    def __init__(self, msg, exception=None):
+        """Creates an exception. The message is required, but the exception
+        is optional."""
+        self._msg = msg
+        self._exception = exception
+        Exception.__init__(self, msg)
+
+    def getMessage(self):
+        "Return a message for this exception."
+        return self._msg
+
+    def getException(self):
+        "Return the embedded exception, or None if there was none."
+        return self._exception
+
+    def __str__(self):
+        "Create a string representation of the exception."
+        return self._msg
+
+    def __getitem__(self, ix):
+        """Avoids weird error messages if someone does exception[ix] by
+        mistake, since Exception has __getitem__ defined."""
+        raise AttributeError("__getitem__")
+
+
+# ===== SAXPARSEEXCEPTION =====
+
+class SAXParseException(SAXException):
+    """Encapsulate an XML parse error or warning.
+
+    This exception will include information for locating the error in
+    the original XML document. Note that although the application will
+    receive a SAXParseException as the argument to the handlers in the
+    ErrorHandler interface, the application is not actually required
+    to throw the exception; instead, it can simply read the
+    information in it and take a different action.
+
+    Since this exception is a subclass of SAXException, it inherits
+    the ability to wrap another exception."""
+
+    def __init__(self, msg, exception, locator):
+        "Creates the exception. The exception parameter is allowed to be None."
+        SAXException.__init__(self, msg, exception)
+        self._locator = locator
+
+        # We need to cache this stuff at construction time.
+        # If this exception is thrown, the objects through which we must
+        # traverse to get this information may be deleted by the time
+        # it gets caught.
+        self._systemId = self._locator.getSystemId()
+        self._colnum = self._locator.getColumnNumber()
+        self._linenum = self._locator.getLineNumber()
+
+    def getColumnNumber(self):
+        """The column number of the end of the text where the exception
+        occurred."""
+        return self._colnum
+
+    def getLineNumber(self):
+        "The line number of the end of the text where the exception occurred."
+        return self._linenum
+
+    def getPublicId(self):
+        "Get the public identifier of the entity where the exception occurred."
+        return self._locator.getPublicId()
+
+    def getSystemId(self):
+        "Get the system identifier of the entity where the exception occurred."
+        return self._systemId
+
+    def __str__(self):
+        "Create a string representation of the exception."
+        sysid = self.getSystemId()
+        if sysid is None:
+            sysid = "<unknown>"
+        linenum = self.getLineNumber()
+        if linenum is None:
+            linenum = "?"
+        colnum = self.getColumnNumber()
+        if colnum is None:
+            colnum = "?"
+        return "%s:%s:%s: %s" % (sysid, linenum, colnum, self._msg)
+
+
+# ===== SAXNOTRECOGNIZEDEXCEPTION =====
+
+class SAXNotRecognizedException(SAXException):
+    """Exception class for an unrecognized identifier.
+
+    An XMLReader will raise this exception when it is confronted with an
+    unrecognized feature or property. SAX applications and extensions may
+    use this class for similar purposes."""
+
+
+# ===== SAXNOTSUPPORTEDEXCEPTION =====
+
+class SAXNotSupportedException(SAXException):
+    """Exception class for an unsupported operation.
+
+    An XMLReader will raise this exception when a service it cannot
+    perform is requested (specifically setting a state or value). SAX
+    applications and extensions may use this class for similar
+    purposes."""
+
+# ===== SAXNOTSUPPORTEDEXCEPTION =====
+
+class SAXReaderNotAvailable(SAXNotSupportedException):
+    """Exception class for a missing driver.
+
+    An XMLReader module (driver) should raise this exception when it
+    is first imported, e.g. when a support module cannot be imported.
+    It also may be raised during parsing, e.g. if executing an external
+    program is not permitted."""

plugins/Jython/Lib/xml/sax/drivers2/__init__.py

@@ -0,0 +1 @@
+"Directory for SAX version 2 drivers."

plugins/Jython/Lib/xml/sax/drivers2/drv_javasax.py

@@ -0,0 +1,417 @@
+"""
+SAX driver for the Java SAX parsers. Can only be used in Jython.
+
+$Id: drv_javasax.py,v 1.5 2003/01/26 09:08:51 loewis Exp $
+"""
+
+# --- Initialization
+
+version = "0.10"
+revision = "$Revision: 1.5 $"
+
+import string
+from xml.sax import xmlreader, saxutils
+from xml.sax.handler import feature_namespaces, feature_namespace_prefixes
+from xml.sax import _exceptions
+
+# we only work in jython
+import sys
+if sys.platform[:4] != "java":
+    raise _exceptions.SAXReaderNotAvailable("drv_javasax not available in CPython", None)
+del sys
+
+# get the necessary Java SAX classes
+try:
+    from org.python.core import FilelikeInputStream
+    from org.xml.sax.helpers import XMLReaderFactory
+    from org.xml import sax as javasax
+    from org.xml.sax.ext import LexicalHandler
+except ImportError:
+    raise _exceptions.SAXReaderNotAvailable("SAX is not on the classpath", None)
+
+# get some JAXP stuff
+try:
+    from javax.xml.parsers import SAXParserFactory, ParserConfigurationException
+    factory = SAXParserFactory.newInstance()
+    # Set this feature false, otherwise will attempt to load DTDs like
+    # DOCTYPE doc PUBLIC 'http://xml.python.org/public which are
+    # purposefully very much nonexistent in tests such as
+    # test_minidom.
+    #
+    # NOTE that this factory is by default nonvalidating anyway, as
+    # needed for Python usage.
+    factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", False)
+    jaxp = 1
+except ImportError:
+    jaxp = 0
+
+from java.lang import String, Exception as JException
+
+class SAXUnicodeDecodeError(UnicodeDecodeError):
+    def __init__(self, message):
+        self.message = message
+    def __repr__(self):
+        return "SAXUnicodeDecodeError: caused by %s" % (self.message,)
+    __str__ = __repr__
+
+
+def _wrap_sax_exception(e):
+    # Work around issues in how we report exceptions to using
+    # code. Note this is an implementation detail, so some assumptions
+    # are required. But if this identification fails, a reasonable exception
+    # will still be thrown.
+    #
+    # Because of some differences in how Oracle packages Xerces, also catch
+    # on the parse method itself.
+    if "MalformedByteSequenceException" in str(e.getException()):
+        return SAXUnicodeDecodeError(str(e))
+    return _exceptions.SAXParseException(e.message,
+                                         e.exception,
+                                         SimpleLocator(e.columnNumber,
+                                                       e.lineNumber,
+                                                       e.publicId,
+                                                       e.systemId))
+
+class JyErrorHandlerWrapper(javasax.ErrorHandler):
+    def __init__(self, err_handler):
+        self._err_handler = err_handler
+
+    def error(self, exc):
+        self._err_handler.error(_wrap_sax_exception(exc))
+
+    def fatalError(self, exc):
+        self._err_handler.fatalError(_wrap_sax_exception(exc))
+
+    def warning(self, exc):
+        self._err_handler.warning(_wrap_sax_exception(exc))
+
+class JyInputSourceWrapper(javasax.InputSource):
+    def __init__(self, source):
+        if isinstance(source, basestring):
+            javasax.InputSource.__init__(self, source)
+        elif hasattr(source, "read"):#file like object
+            f = source
+            javasax.InputSource.__init__(self, FilelikeInputStream(f))
+            if hasattr(f, "name"):
+                self.setSystemId(f.name)
+        else:#xml.sax.xmlreader.InputSource object
+            #Use byte stream constructor if possible so that Xerces won't attempt to open
+            #the url at systemId unless it's really there
+            if source.getByteStream():
+                javasax.InputSource.__init__(self,
+                                             FilelikeInputStream(source.getByteStream()))
+            else:
+                javasax.InputSource.__init__(self)
+            if source.getSystemId():
+                self.setSystemId(source.getSystemId())
+            self.setPublicId(source.getPublicId())
+            self.setEncoding(source.getEncoding())
+
+class JyEntityResolverWrapper(javasax.EntityResolver):
+    def __init__(self, entityResolver):
+        self._resolver = entityResolver
+
+    def resolveEntity(self, pubId, sysId):
+        return JyInputSourceWrapper(self._resolver.resolveEntity(pubId, sysId))
+
+class JyDTDHandlerWrapper(javasax.DTDHandler):
+    def __init__(self, dtdHandler):
+        self._handler = dtdHandler
+
+    def notationDecl(self, name, publicId, systemId):
+        self._handler.notationDecl(name, publicId, systemId)
+
+    def unparsedEntityDecl(self, name, publicId, systemId, notationName):
+        self._handler.unparsedEntityDecl(name, publicId, systemId, notationName)
+
+class SimpleLocator(xmlreader.Locator):
+    def __init__(self, colNum, lineNum, pubId, sysId):
+        self.colNum = colNum
+        self.lineNum = lineNum
+        self.pubId = pubId
+        self.sysId = sysId
+
+    def getColumnNumber(self):
+        return self.colNum
+
+    def getLineNumber(self):
+        return self.lineNum
+
+    def getPublicId(self):
+        return self.pubId
+
+    def getSystemId(self):
+        return self.sysId
+
+# --- JavaSAXParser
+class JavaSAXParser(xmlreader.XMLReader, javasax.ContentHandler, LexicalHandler):
+    "SAX driver for the Java SAX parsers."
+
+    def __init__(self, jdriver = None):
+        xmlreader.XMLReader.__init__(self)
+        self._parser = create_java_parser(jdriver)
+        self._parser.setFeature(feature_namespaces, 0)
+        self._parser.setFeature(feature_namespace_prefixes, 0)
+        self._parser.setContentHandler(self)
+        self._nsattrs = AttributesNSImpl()
+        self._attrs = AttributesImpl()
+        self.setEntityResolver(self.getEntityResolver())
+        self.setErrorHandler(self.getErrorHandler())
+        self.setDTDHandler(self.getDTDHandler())
+        try:
+            self._parser.setProperty("http://xml.org/sax/properties/lexical-handler", self)
+        except Exception, x:
+            pass
+
+    # XMLReader methods
+
+    def parse(self, source):
+        "Parse an XML document from a URL or an InputSource."
+        try:
+            self._parser.parse(JyInputSourceWrapper(source))
+        except JException as e:
+            # Handle the difference in how Oracle packages Xerces...
+            if "MalformedByteSequenceException" in str(e):
+                raise SAXUnicodeDecodeError(str(e))
+            else:
+                raise
+
+    def getFeature(self, name):
+        return self._parser.getFeature(name)
+
+    def setFeature(self, name, state):
+        self._parser.setFeature(name, state)
+
+    def getProperty(self, name):
+        return self._parser.getProperty(name)
+
+    def setProperty(self, name, value):
+        self._parser.setProperty(name, value)
+
+    def setEntityResolver(self, resolver):
+        self._parser.entityResolver = JyEntityResolverWrapper(resolver)
+        xmlreader.XMLReader.setEntityResolver(self, resolver)
+
+    def setErrorHandler(self, err_handler):
+        self._parser.errorHandler = JyErrorHandlerWrapper(err_handler)
+        xmlreader.XMLReader.setErrorHandler(self, err_handler)
+
+    def setDTDHandler(self, dtd_handler):
+        self._parser.setDTDHandler(JyDTDHandlerWrapper(dtd_handler))
+        xmlreader.XMLReader.setDTDHandler(self, dtd_handler)
+
+    # ContentHandler methods
+    def setDocumentLocator(self, locator):
+        self._cont_handler.setDocumentLocator(locator)
+
+    def startDocument(self):
+        self._cont_handler.startDocument()
+        self._namespaces = self._parser.getFeature(feature_namespaces)
+
+    def startElement(self, uri, lname, qname, attrs):
+        if self._namespaces:
+            self._nsattrs._attrs = attrs
+            self._cont_handler.startElementNS((uri or None, lname), qname,
+                                              self._nsattrs)
+        else:
+            self._attrs._attrs = attrs
+            self._cont_handler.startElement(qname, self._attrs)
+
+    def startPrefixMapping(self, prefix, uri):
+        self._cont_handler.startPrefixMapping(prefix, uri)
+
+    def characters(self, char, start, len):
+        self._cont_handler.characters(unicode(String(char, start, len)))
+
+    def ignorableWhitespace(self, char, start, len):
+        self._cont_handler.ignorableWhitespace(unicode(String(char, start,
+                                                              len)))
+
+    def endElement(self, uri, lname, qname):
+        if self._namespaces:
+            self._cont_handler.endElementNS((uri or None, lname), qname)
+        else:
+            self._cont_handler.endElement(qname)
+
+    def endPrefixMapping(self, prefix):
+        self._cont_handler.endPrefixMapping(prefix)
+
+    def endDocument(self):
+        self._cont_handler.endDocument()
+
+    def processingInstruction(self, target, data):
+        self._cont_handler.processingInstruction(target, data)
+
+    # Lexical handler methods
+    def comment(self, char, start, len):
+        try:
+            # Need to wrap this in a try..except in case the parser does not support lexical events
+            self._cont_handler.comment(unicode(String(char, start, len)))
+        except:
+            pass
+
+    def startCDATA(self):
+        pass # TODO
+
+    def endCDATA(self):
+        pass # TODO
+
+    def startDTD(self, name, publicId, systemId):
+        pass # TODO
+
+    def endDTD(self):
+        pass # TODO
+
+    def startEntity(self, name):
+        pass # TODO
+
+    def endEntity(self, name):
+        pass # TODO
+
+    def skippedEntity(self, name):
+        pass
+
+
+def _fixTuple(nsTuple, frm, to):
+    if isinstance(nsTuple, tuple) and len(nsTuple) == 2:
+        nsUri, localName = nsTuple
+        if nsUri == frm:
+            nsUri = to
+        return (nsUri, localName)
+    return nsTuple
+
+def _makeJavaNsTuple(nsTuple):
+    return _fixTuple(nsTuple, None, '')
+
+def _makePythonNsTuple(nsTuple):
+    return _fixTuple(nsTuple, '', None)
+
+class AttributesImpl:
+
+    def __init__(self, attrs = None):
+        self._attrs = attrs
+
+    def getLength(self):
+        return self._attrs.getLength()
+
+    def getType(self, name):
+        return self._attrs.getType(_makeJavaNsTuple(name))
+
+    def getValue(self, name):
+        value = self._attrs.getValue(_makeJavaNsTuple(name))
+        if value == None:
+            raise KeyError(name)
+        return value
+
+    def getNames(self):
+        return [_makePythonNsTuple(self._attrs.getQName(index)) for index in range(len(self))]
+
+    def getQNames(self):
+        return [self._attrs.getQName(index) for index in range(len(self))]
+
+    def getValueByQName(self, qname):
+        idx = self._attrs.getIndex(qname)
+        if idx == -1:
+            raise KeyError, qname
+        return self._attrs.getValue(idx)
+
+    def getNameByQName(self, qname):
+        idx = self._attrs.getIndex(qname)
+        if idx == -1:
+            raise KeyError, qname
+        return qname
+
+    def getQNameByName(self, name):
+        idx = self._attrs.getIndex(_makeJavaNsTuple(name))
+        if idx == -1:
+            raise KeyError, name
+        return name
+
+    def __len__(self):
+        return self._attrs.getLength()
+
+    def __getitem__(self, name):
+        return self.getValue(name)
+
+    def keys(self):
+        return self.getNames()
+
+    def copy(self):
+        return self.__class__(self._attrs)
+
+    def items(self):
+        return [(name, self[name]) for name in self.getNames()]
+
+    def values(self):
+        return map(self.getValue, self.getNames())
+
+    def get(self, name, alt=None):
+        try:
+            return self.getValue(name)
+        except KeyError:
+            return alt
+
+    def has_key(self, name):
+        try:
+            self.getValue(name)
+            return True
+        except KeyError:
+            return False
+
+# --- AttributesNSImpl
+
+class AttributesNSImpl(AttributesImpl):
+
+    def __init__(self, attrs=None):
+        AttributesImpl.__init__(self, attrs)
+
+    def getType(self, name):
+        name = _makeJavaNsTuple(name)
+        return self._attrs.getType(name[0], name[1])
+
+    def getValue(self, name):
+        jname = _makeJavaNsTuple(name)
+        value = self._attrs.getValue(jname[0], jname[1])
+        if value == None:
+            raise KeyError(name)
+        return value
+
+    def getNames(self):
+        names = []
+        for idx in range(len(self)):
+            names.append(_makePythonNsTuple( (self._attrs.getURI(idx), self._attrs.getLocalName(idx)) ))
+        return names
+
+    def getNameByQName(self, qname):
+        idx = self._attrs.getIndex(qname)
+        if idx == -1:
+            raise KeyError, qname
+        return _makePythonNsTuple( (self._attrs.getURI(idx), self._attrs.getLocalName(idx)) )
+
+    def getQNameByName(self, name):
+        name = _makeJavaNsTuple(name)
+        idx = self._attrs.getIndex(name[0], name[1])
+        if idx == -1:
+            raise KeyError, name
+        return self._attrs.getQName(idx)
+
+    def getQNames(self):
+        return [self._attrs.getQName(idx) for idx in range(len(self))]
+
+# ---
+
+def create_java_parser(jdriver = None):
+    try:
+        if jdriver:
+            return XMLReaderFactory.createXMLReader(jdriver)
+        elif jaxp:
+            return factory.newSAXParser().getXMLReader()
+        else:
+            return XMLReaderFactory.createXMLReader()
+    except ParserConfigurationException, e:
+        raise _exceptions.SAXReaderNotAvailable(e.getMessage())
+    except javasax.SAXException, e:
+        raise _exceptions.SAXReaderNotAvailable(e.getMessage())
+
+def create_parser(jdriver = None):
+    return JavaSAXParser(jdriver)

plugins/Jython/Lib/xml/sax/handler.py

@@ -0,0 +1,345 @@
+"""
+This module contains the core classes of version 2.0 of SAX for Python.
+This file provides only default classes with absolutely minimum
+functionality, from which drivers and applications can be subclassed.
+
+Many of these classes are empty and are included only as documentation
+of the interfaces.
+
+$Id: handler.py,v 1.5 2002/02/14 08:09:36 loewis Exp $
+"""
+
+version = '2.0beta'
+
+#============================================================================
+#
+# HANDLER INTERFACES
+#
+#============================================================================
+
+# ===== ERRORHANDLER =====
+
+class ErrorHandler:
+    """Basic interface for SAX error handlers.
+
+    If you create an object that implements this interface, then
+    register the object with your XMLReader, the parser will call the
+    methods in your object to report all warnings and errors. There
+    are three levels of errors available: warnings, (possibly)
+    recoverable errors, and unrecoverable errors. All methods take a
+    SAXParseException as the only parameter."""
+
+    def error(self, exception):
+        "Handle a recoverable error."
+        raise exception
+
+    def fatalError(self, exception):
+        "Handle a non-recoverable error."
+        raise exception
+
+    def warning(self, exception):
+        "Handle a warning."
+        print exception
+
+
+# ===== CONTENTHANDLER =====
+
+class ContentHandler:
+    """Interface for receiving logical document content events.
+
+    This is the main callback interface in SAX, and the one most
+    important to applications. The order of events in this interface
+    mirrors the order of the information in the document."""
+
+    def __init__(self):
+        self._locator = None
+
+    def setDocumentLocator(self, locator):
+        """Called by the parser to give the application a locator for
+        locating the origin of document events.
+
+        SAX parsers are strongly encouraged (though not absolutely
+        required) to supply a locator: if it does so, it must supply
+        the locator to the application by invoking this method before
+        invoking any of the other methods in the DocumentHandler
+        interface.
+
+        The locator allows the application to determine the end
+        position of any document-related event, even if the parser is
+        not reporting an error. Typically, the application will use
+        this information for reporting its own errors (such as
+        character content that does not match an application's
+        business rules). The information returned by the locator is
+        probably not sufficient for use with a search engine.
+
+        Note that the locator will return correct information only
+        during the invocation of the events in this interface. The
+        application should not attempt to use it at any other time."""
+        self._locator = locator
+
+    def startDocument(self):
+        """Receive notification of the beginning of a document.
+
+        The SAX parser will invoke this method only once, before any
+        other methods in this interface or in DTDHandler (except for
+        setDocumentLocator)."""
+
+    def endDocument(self):
+        """Receive notification of the end of a document.
+
+        The SAX parser will invoke this method only once, and it will
+        be the last method invoked during the parse. The parser shall
+        not invoke this method until it has either abandoned parsing
+        (because of an unrecoverable error) or reached the end of
+        input."""
+
+    def startPrefixMapping(self, prefix, uri):
+        """Begin the scope of a prefix-URI Namespace mapping.
+
+        The information from this event is not necessary for normal
+        Namespace processing: the SAX XML reader will automatically
+        replace prefixes for element and attribute names when the
+        http://xml.org/sax/features/namespaces feature is true (the
+        default).
+
+        There are cases, however, when applications need to use
+        prefixes in character data or in attribute values, where they
+        cannot safely be expanded automatically; the
+        start/endPrefixMapping event supplies the information to the
+        application to expand prefixes in those contexts itself, if
+        necessary.
+
+        Note that start/endPrefixMapping events are not guaranteed to
+        be properly nested relative to each-other: all
+        startPrefixMapping events will occur before the corresponding
+        startElement event, and all endPrefixMapping events will occur
+        after the corresponding endElement event, but their order is
+        not guaranteed."""
+
+    def endPrefixMapping(self, prefix):
+        """End the scope of a prefix-URI mapping.
+
+        See startPrefixMapping for details. This event will always
+        occur after the corresponding endElement event, but the order
+        of endPrefixMapping events is not otherwise guaranteed."""
+
+    def startElement(self, name, attrs):
+        """Signals the start of an element in non-namespace mode.
+
+        The name parameter contains the raw XML 1.0 name of the
+        element type as a string and the attrs parameter holds an
+        instance of the Attributes class containing the attributes of
+        the element."""
+
+    def endElement(self, name):
+        """Signals the end of an element in non-namespace mode.
+
+        The name parameter contains the name of the element type, just
+        as with the startElement event."""
+
+    def startElementNS(self, name, qname, attrs):
+        """Signals the start of an element in namespace mode.
+
+        The name parameter contains the name of the element type as a
+        (uri, localname) tuple, the qname parameter the raw XML 1.0
+        name used in the source document, and the attrs parameter
+        holds an instance of the Attributes class containing the
+        attributes of the element.
+
+        The uri part of the name tuple is None for elements which have
+        no namespace."""
+
+    def endElementNS(self, name, qname):
+        """Signals the end of an element in namespace mode.
+
+        The name parameter contains the name of the element type, just
+        as with the startElementNS event."""
+
+    def characters(self, content):
+        """Receive notification of character data.
+
+        The Parser will call this method to report each chunk of
+        character data. SAX parsers may return all contiguous
+        character data in a single chunk, or they may split it into
+        several chunks; however, all of the characters in any single
+        event must come from the same external entity so that the
+        Locator provides useful information."""
+
+    def ignorableWhitespace(self, whitespace):
+        """Receive notification of ignorable whitespace in element content.
+
+        Validating Parsers must use this method to report each chunk
+        of ignorable whitespace (see the W3C XML 1.0 recommendation,
+        section 2.10): non-validating parsers may also use this method
+        if they are capable of parsing and using content models.
+
+        SAX parsers may return all contiguous whitespace in a single
+        chunk, or they may split it into several chunks; however, all
+        of the characters in any single event must come from the same
+        external entity, so that the Locator provides useful
+        information.
+
+        The application must not attempt to read from the array
+        outside of the specified range."""
+
+    def processingInstruction(self, target, data):
+        """Receive notification of a processing instruction.
+
+        The Parser will invoke this method once for each processing
+        instruction found: note that processing instructions may occur
+        before or after the main document element.
+
+        A SAX parser should never report an XML declaration (XML 1.0,
+        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
+        using this method."""
+
+    def skippedEntity(self, name):
+        """Receive notification of a skipped entity.
+
+        The Parser will invoke this method once for each entity
+        skipped. Non-validating processors may skip entities if they
+        have not seen the declarations (because, for example, the
+        entity was declared in an external DTD subset). All processors
+        may skip external entities, depending on the values of the
+        http://xml.org/sax/features/external-general-entities and the
+        http://xml.org/sax/features/external-parameter-entities
+        properties."""
+
+
+# ===== DTDHandler =====
+
+class DTDHandler:
+    """Handle DTD events.
+
+    This interface specifies only those DTD events required for basic
+    parsing (unparsed entities and attributes)."""
+
+    def notationDecl(self, name, publicId, systemId):
+        "Handle a notation declaration event."
+
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata):
+        "Handle an unparsed entity declaration event."
+
+
+# ===== ENTITYRESOLVER =====
+
+class EntityResolver:
+    """Basic interface for resolving entities. If you create an object
+    implementing this interface, then register the object with your
+    Parser, the parser will call the method in your object to
+    resolve all external entities. Note that DefaultHandler implements
+    this interface with the default behaviour."""
+
+    def resolveEntity(self, publicId, systemId):
+        """Resolve the system identifier of an entity and return either
+        the system identifier to read from as a string, or an InputSource
+        to read from."""
+        return systemId
+
+
+#============================================================================
+#
+# CORE FEATURES
+#
+#============================================================================
+
+feature_namespaces = "http://xml.org/sax/features/namespaces"
+# true: Perform Namespace processing (default).
+# false: Optionally do not perform Namespace processing
+#        (implies namespace-prefixes).
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_namespace_prefixes = "http://xml.org/sax/features/namespace-prefixes"
+# true: Report the original prefixed names and attributes used for Namespace
+#       declarations.
+# false: Do not report attributes used for Namespace declarations, and
+#        optionally do not report original prefixed names (default).
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_string_interning = "http://xml.org/sax/features/string-interning"
+# true: All element names, prefixes, attribute names, Namespace URIs, and
+#       local names are interned using the built-in intern function.
+# false: Names are not necessarily interned, although they may be (default).
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_validation = "http://xml.org/sax/features/validation"
+# true: Report all validation errors (implies external-general-entities and
+#       external-parameter-entities).
+# false: Do not report validation errors.
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_external_ges = "http://xml.org/sax/features/external-general-entities"
+# true: Include all external general (text) entities.
+# false: Do not include external general entities.
+# access: (parsing) read-only; (not parsing) read/write
+
+feature_external_pes = "http://xml.org/sax/features/external-parameter-entities"
+# true: Include all external parameter entities, including the external
+#       DTD subset.
+# false: Do not include any external parameter entities, even the external
+#        DTD subset.
+# access: (parsing) read-only; (not parsing) read/write
+
+all_features = [feature_namespaces,
+                feature_namespace_prefixes,
+                feature_string_interning,
+                feature_validation,
+                feature_external_ges,
+                feature_external_pes]
+
+
+#============================================================================
+#
+# CORE PROPERTIES
+#
+#============================================================================
+
+property_lexical_handler = "http://xml.org/sax/properties/lexical-handler"
+# data type: xml.sax.sax2lib.LexicalHandler
+# description: An optional extension handler for lexical events like comments.
+# access: read/write
+
+property_declaration_handler = "http://xml.org/sax/properties/declaration-handler"
+# data type: xml.sax.sax2lib.DeclHandler
+# description: An optional extension handler for DTD-related events other
+#              than notations and unparsed entities.
+# access: read/write
+
+property_dom_node = "http://xml.org/sax/properties/dom-node"
+# data type: org.w3c.dom.Node
+# description: When parsing, the current DOM node being visited if this is
+#              a DOM iterator; when not parsing, the root DOM node for
+#              iteration.
+# access: (parsing) read-only; (not parsing) read/write
+
+property_xml_string = "http://xml.org/sax/properties/xml-string"
+# data type: String
+# description: The literal string of characters that was the source for
+#              the current event.
+# access: read-only
+
+property_encoding = "http://www.python.org/sax/properties/encoding"
+# data type: String
+# description: The name of the encoding to assume for input data.
+# access: write: set the encoding, e.g. established by a higher-level
+#                protocol. May change during parsing (e.g. after
+#                processing a META tag)
+#         read:  return the current encoding (possibly established through
+#                auto-detection.
+# initial value: UTF-8
+#
+
+property_interning_dict = "http://www.python.org/sax/properties/interning-dict"
+# data type: Dictionary
+# description: The dictionary used to intern common strings in the document
+# access: write: Request that the parser uses a specific dictionary, to
+#                allow interning across different documents
+#         read:  return the current interning dictionary, or None
+#
+
+all_properties = [property_lexical_handler,
+                  property_dom_node,
+                  property_declaration_handler,
+                  property_xml_string,
+                  property_encoding,
+                  property_interning_dict]

plugins/Jython/Lib/xml/sax/saxlib.py

@@ -0,0 +1,430 @@
+"""
+This module contains the core classes of version 2.0 of SAX for Python.
+This file provides only default classes with absolutely minimum
+functionality, from which drivers and applications can be subclassed.
+
+Many of these classes are empty and are included only as documentation
+of the interfaces.
+
+$Id: saxlib.py,v 1.12 2002/05/10 14:49:21 akuchling Exp $
+"""
+
+version = '2.0beta'
+
+# A number of interfaces used to live in saxlib, but are now in
+# various other modules for Python 2 compatibility. If nobody uses
+# them here any longer, the references can be removed
+
+from handler import ErrorHandler, ContentHandler, DTDHandler, EntityResolver
+from xmlreader import XMLReader, InputSource, Locator, IncrementalParser
+from _exceptions import *
+
+from handler import \
+     feature_namespaces,\
+     feature_namespace_prefixes,\
+     feature_string_interning,\
+     feature_validation,\
+     feature_external_ges,\
+     feature_external_pes,\
+     all_features,\
+     property_lexical_handler,\
+     property_declaration_handler,\
+     property_dom_node,\
+     property_xml_string,\
+     all_properties
+
+#============================================================================
+#
+# MAIN INTERFACES
+#
+#============================================================================
+
+# ===== XMLFILTER =====
+
+class XMLFilter(XMLReader):
+    """Interface for a SAX2 parser filter.
+
+    A parser filter is an XMLReader that gets its events from another
+    XMLReader (which may in turn also be a filter) rather than from a
+    primary source like a document or other non-SAX data source.
+    Filters can modify a stream of events before passing it on to its
+    handlers."""
+
+    def __init__(self, parent = None):
+        """Creates a filter instance, allowing applications to set the
+        parent on instantiation."""
+        XMLReader.__init__(self)
+        self._parent = parent
+
+    def setParent(self, parent):
+        """Sets the parent XMLReader of this filter. The argument may
+        not be None."""
+        self._parent = parent
+
+    def getParent(self):
+        "Returns the parent of this filter."
+        return self._parent
+
+# ===== ATTRIBUTES =====
+
+class Attributes:
+    """Interface for a list of XML attributes.
+
+    Contains a list of XML attributes, accessible by name."""
+
+    def getLength(self):
+        "Returns the number of attributes in the list."
+        raise NotImplementedError("This method must be implemented!")
+
+    def getType(self, name):
+        "Returns the type of the attribute with the given name."
+        raise NotImplementedError("This method must be implemented!")
+
+    def getValue(self, name):
+        "Returns the value of the attribute with the given name."
+        raise NotImplementedError("This method must be implemented!")
+
+    def getValueByQName(self, name):
+        """Returns the value of the attribute with the given raw (or
+        qualified) name."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def getNameByQName(self, name):
+        """Returns the namespace name of the attribute with the given
+        raw (or qualified) name."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def getNames(self):
+        """Returns a list of the names of all attributes
+        in the list."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def getQNames(self):
+        """Returns a list of the raw qualified names of all attributes
+        in the list."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def __len__(self):
+        "Alias for getLength."
+        raise NotImplementedError("This method must be implemented!")
+
+    def __getitem__(self, name):
+        "Alias for getValue."
+        raise NotImplementedError("This method must be implemented!")
+
+    def keys(self):
+        "Returns a list of the attribute names in the list."
+        raise NotImplementedError("This method must be implemented!")
+
+    def has_key(self, name):
+        "True if the attribute is in the list, false otherwise."
+        raise NotImplementedError("This method must be implemented!")
+
+    def get(self, name, alternative=None):
+        """Return the value associated with attribute name; if it is not
+        available, then return the alternative."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def copy(self):
+        "Return a copy of the Attributes object."
+        raise NotImplementedError("This method must be implemented!")
+
+    def items(self):
+        "Return a list of (attribute_name, value) pairs."
+        raise NotImplementedError("This method must be implemented!")
+
+    def values(self):
+        "Return a list of all attribute values."
+        raise NotImplementedError("This method must be implemented!")
+
+
+#============================================================================
+#
+# HANDLER INTERFACES
+#
+#============================================================================
+
+
+# ===== DECLHANDLER =====
+
+class DeclHandler:
+    """Optional SAX2 handler for DTD declaration events.
+
+    Note that some DTD declarations are already reported through the
+    DTDHandler interface. All events reported to this handler will
+    occur between the startDTD and endDTD events of the
+    LexicalHandler.
+
+    To set the DeclHandler for an XMLReader, use the setProperty method
+    with the identifier http://xml.org/sax/handlers/DeclHandler."""
+
+    def attributeDecl(self, elem_name, attr_name, type, value_def, value):
+        """Report an attribute type declaration.
+
+        Only the first declaration will be reported. The type will be
+        one of the strings "CDATA", "ID", "IDREF", "IDREFS",
+        "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES", or "NOTATION", or
+        a list of names (in the case of enumerated definitions).
+
+        elem_name is the element type name, attr_name the attribute
+        type name, type a string representing the attribute type,
+        value_def a string representing the default declaration
+        ('#IMPLIED', '#REQUIRED', '#FIXED' or None). value is a string
+        representing the attribute's default value, or None if there
+        is none."""
+
+    def elementDecl(self, elem_name, content_model):
+        """Report an element type declaration.
+
+        Only the first declaration will be reported.
+
+        content_model is the string 'EMPTY', the string 'ANY' or the content
+        model structure represented as tuple (separator, tokens, modifier)
+        where separator is the separator in the token list (that is, '|' or
+        ','), tokens is the list of tokens (element type names or tuples
+        representing parentheses) and modifier is the quantity modifier
+        ('*', '?' or '+')."""
+
+    def internalEntityDecl(self, name, value):
+        """Report an internal entity declaration.
+
+        Only the first declaration of an entity will be reported.
+
+        name is the name of the entity. If it is a parameter entity,
+        the name will begin with '%'. value is the replacement text of
+        the entity."""
+
+    def externalEntityDecl(self, name, public_id, system_id):
+        """Report a parsed entity declaration. (Unparsed entities are
+        reported to the DTDHandler.)
+
+        Only the first declaration for each entity will be reported.
+
+        name is the name of the entity. If it is a parameter entity,
+        the name will begin with '%'. public_id and system_id are the
+        public and system identifiers of the entity. public_id will be
+        None if none were declared."""
+
+
+
+# ===== LEXICALHANDLER =====
+
+class LexicalHandler:
+    """Optional SAX2 handler for lexical events.
+
+    This handler is used to obtain lexical information about an XML
+    document, that is, information about how the document was encoded
+    (as opposed to what it contains, which is reported to the
+    ContentHandler), such as comments and CDATA marked section
+    boundaries.
+
+    To set the LexicalHandler of an XMLReader, use the setProperty
+    method with the property identifier
+    'http://xml.org/sax/handlers/LexicalHandler'. There is no
+    guarantee that the XMLReader will support or recognize this
+    property."""
+
+    def comment(self, content):
+        """Reports a comment anywhere in the document (including the
+        DTD and outside the document element).
+
+        content is a string that holds the contents of the comment."""
+
+    def startDTD(self, name, public_id, system_id):
+        """Report the start of the DTD declarations, if the document
+        has an associated DTD.
+
+        A startEntity event will be reported before declaration events
+        from the external DTD subset are reported, and this can be
+        used to infer from which subset DTD declarations derive.
+
+        name is the name of the document element type, public_id the
+        public identifier of the DTD (or None if none were supplied)
+        and system_id the system identfier of the external subset (or
+        None if none were supplied)."""
+
+    def endDTD(self):
+        "Signals the end of DTD declarations."
+
+    def startEntity(self, name):
+        """Report the beginning of an entity.
+
+        The start and end of the document entity is not reported. The
+        start and end of the external DTD subset is reported with the
+        pseudo-name '[dtd]'.
+
+        Skipped entities will be reported through the skippedEntity
+        event of the ContentHandler rather than through this event.
+
+        name is the name of the entity. If it is a parameter entity,
+        the name will begin with '%'."""
+
+    def endEntity(self, name):
+        """Reports the end of an entity. name is the name of the
+        entity, and follows the same conventions as for
+        startEntity."""
+
+    def startCDATA(self):
+        """Reports the beginning of a CDATA marked section.
+
+        The contents of the CDATA marked section will be reported
+        through the characters event."""
+
+    def endCDATA(self):
+        "Reports the end of a CDATA marked section."
+
+
+#============================================================================
+#
+# SAX 1.0 COMPATIBILITY CLASSES
+# Note that these are all deprecated.
+#
+#============================================================================
+
+# ===== ATTRIBUTELIST =====
+
+class AttributeList:
+    """Interface for an attribute list. This interface provides
+    information about a list of attributes for an element (only
+    specified or defaulted attributes will be reported). Note that the
+    information returned by this object will be valid only during the
+    scope of the DocumentHandler.startElement callback, and the
+    attributes will not necessarily be provided in the order declared
+    or specified."""
+
+    def getLength(self):
+        "Return the number of attributes in list."
+
+    def getName(self, i):
+        "Return the name of an attribute in the list."
+
+    def getType(self, i):
+        """Return the type of an attribute in the list. (Parameter can be
+        either integer index or attribute name.)"""
+
+    def getValue(self, i):
+        """Return the value of an attribute in the list. (Parameter can be
+        either integer index or attribute name.)"""
+
+    def __len__(self):
+        "Alias for getLength."
+
+    def __getitem__(self, key):
+        "Alias for getName (if key is an integer) and getValue (if string)."
+
+    def keys(self):
+        "Returns a list of the attribute names."
+
+    def has_key(self, key):
+        "True if the attribute is in the list, false otherwise."
+
+    def get(self, key, alternative=None):
+        """Return the value associated with attribute name; if it is not
+        available, then return the alternative."""
+
+    def copy(self):
+        "Return a copy of the AttributeList."
+
+    def items(self):
+        "Return a list of (attribute_name,value) pairs."
+
+    def values(self):
+        "Return a list of all attribute values."
+
+
+# ===== DOCUMENTHANDLER =====
+
+class DocumentHandler:
+    """Handle general document events. This is the main client
+    interface for SAX: it contains callbacks for the most important
+    document events, such as the start and end of elements. You need
+    to create an object that implements this interface, and then
+    register it with the Parser. If you do not want to implement
+    the entire interface, you can derive a class from HandlerBase,
+    which implements the default functionality. You can find the
+    location of any document event using the Locator interface
+    supplied by setDocumentLocator()."""
+
+    def characters(self, ch, start, length):
+        "Handle a character data event."
+
+    def endDocument(self):
+        "Handle an event for the end of a document."
+
+    def endElement(self, name):
+        "Handle an event for the end of an element."
+
+    def ignorableWhitespace(self, ch, start, length):
+        "Handle an event for ignorable whitespace in element content."
+
+    def processingInstruction(self, target, data):
+        "Handle a processing instruction event."
+
+    def setDocumentLocator(self, locator):
+        "Receive an object for locating the origin of SAX document events."
+
+    def startDocument(self):
+        "Handle an event for the beginning of a document."
+
+    def startElement(self, name, atts):
+        "Handle an event for the beginning of an element."
+
+
+# ===== HANDLERBASE =====
+
+class HandlerBase(EntityResolver, DTDHandler, DocumentHandler,\
+                     ErrorHandler):
+    """Default base class for handlers. This class implements the
+    default behaviour for four SAX interfaces: EntityResolver,
+    DTDHandler, DocumentHandler, and ErrorHandler: rather
+    than implementing those full interfaces, you may simply extend
+    this class and override the methods that you need. Note that the
+    use of this class is optional (you are free to implement the
+    interfaces directly if you wish)."""
+
+
+# ===== PARSER =====
+
+class Parser:
+    """Basic interface for SAX (Simple API for XML) parsers. All SAX
+    parsers must implement this basic interface: it allows users to
+    register handlers for different types of events and to initiate a
+    parse from a URI, a character stream, or a byte stream. SAX
+    parsers should also implement a zero-argument constructor."""
+
+    def __init__(self):
+        self.doc_handler = DocumentHandler()
+        self.dtd_handler = DTDHandler()
+        self.ent_handler = EntityResolver()
+        self.err_handler = ErrorHandler()
+
+    def parse(self, systemId):
+        "Parse an XML document from a system identifier."
+
+    def parseFile(self, fileobj):
+        "Parse an XML document from a file-like object."
+
+    def setDocumentHandler(self, handler):
+        "Register an object to receive basic document-related events."
+        self.doc_handler=handler
+
+    def setDTDHandler(self, handler):
+        "Register an object to receive basic DTD-related events."
+        self.dtd_handler=handler
+
+    def setEntityResolver(self, resolver):
+        "Register an object to resolve external entities."
+        self.ent_handler=resolver
+
+    def setErrorHandler(self, handler):
+        "Register an object to receive error-message events."
+        self.err_handler=handler
+
+    def setLocale(self, locale):
+        """Allow an application to set the locale for errors and warnings.
+
+        SAX parsers are not required to provide localisation for errors
+        and warnings; if they cannot support the requested locale,
+        however, they must throw a SAX exception. Applications may
+        request a locale change in the middle of a parse."""
+        raise SAXNotSupportedException("Locale support not implemented")

plugins/Jython/Lib/xml/sax/saxutils.py

@@ -0,0 +1,813 @@
+"""
+A library of useful helper classes to the saxlib classes, for the
+convenience of application and driver writers.
+
+$Id: saxutils.py,v 1.37 2005/04/13 14:02:08 syt Exp $
+"""
+import os, urlparse, urllib2, types
+import handler
+import xmlreader
+import sys, _exceptions, saxlib
+
+from xml.Uri import Absolutize, MakeUrllibSafe,IsAbsolute
+
+try:
+    _StringTypes = [types.StringType, types.UnicodeType]
+except AttributeError: # 1.5 compatibility:UnicodeType not defined
+    _StringTypes = [types.StringType]
+
+def __dict_replace(s, d):
+    """Replace substrings of a string using a dictionary."""
+    for key, value in d.items():
+        s = s.replace(key, value)
+    return s
+
+def escape(data, entities={}):
+    """Escape &, <, and > in a string of data.
+
+    You can escape other strings of data by passing a dictionary as
+    the optional entities parameter.  The keys and values must all be
+    strings; each key will be replaced with its corresponding value.
+    """
+    data = data.replace("&", "&amp;")
+    data = data.replace("<", "&lt;")
+    data = data.replace(">", "&gt;")
+    if entities:
+        data = __dict_replace(data, entities)
+    return data
+
+def unescape(data, entities={}):
+    """Unescape &amp;, &lt;, and &gt; in a string of data.
+
+    You can unescape other strings of data by passing a dictionary as
+    the optional entities parameter.  The keys and values must all be
+    strings; each key will be replaced with its corresponding value.
+    """
+    data = data.replace("&lt;", "<")
+    data = data.replace("&gt;", ">")
+    if entities:
+        data = __dict_replace(data, entities)
+    # must do ampersand last
+    return data.replace("&amp;", "&")
+
+def quoteattr(data, entities={}):
+    """Escape and quote an attribute value.
+
+    Escape &, <, and > in a string of data, then quote it for use as
+    an attribute value.  The \" character will be escaped as well, if
+    necessary.
+
+    You can escape other strings of data by passing a dictionary as
+    the optional entities parameter.  The keys and values must all be
+    strings; each key will be replaced with its corresponding value.
+    """
+    data = escape(data, entities)
+    if '"' in data:
+        if "'" in data:
+            data = '"%s"' % data.replace('"', "&quot;")
+        else:
+            data = "'%s'" % data
+    else:
+        data = '"%s"' % data
+    return data
+
+# --- DefaultHandler
+
+class DefaultHandler(handler.EntityResolver, handler.DTDHandler,
+                     handler.ContentHandler, handler.ErrorHandler):
+    """Default base class for SAX2 event handlers. Implements empty
+    methods for all callback methods, which can be overridden by
+    application implementors. Replaces the deprecated SAX1 HandlerBase
+    class."""
+
+# --- Location
+
+class Location:
+    """Represents a location in an XML entity. Initialized by being passed
+    a locator, from which it reads off the current location, which is then
+    stored internally."""
+
+    def __init__(self, locator):
+        self.__col = locator.getColumnNumber()
+        self.__line = locator.getLineNumber()
+        self.__pubid = locator.getPublicId()
+        self.__sysid = locator.getSystemId()
+
+    def getColumnNumber(self):
+        return self.__col
+
+    def getLineNumber(self):
+        return self.__line
+
+    def getPublicId(self):
+        return self.__pubid
+
+    def getSystemId(self):
+        return self.__sysid
+
+    def __str__(self):
+        if self.__line is None:
+            line = "?"
+        else:
+            line = self.__line
+        if self.__col is None:
+            col = "?"
+        else:
+            col = self.__col
+        return "%s:%s:%s" % (
+            self.__sysid or self.__pubid or "<unknown>",
+            line, col)
+
+# --- ErrorPrinter
+
+class ErrorPrinter:
+    "A simple class that just prints error messages to standard out."
+
+    def __init__(self, level=0, outfile=sys.stderr):
+        self._level = level
+        self._outfile = outfile
+
+    def warning(self, exception):
+        if self._level <= 0:
+            self._outfile.write("WARNING in %s: %s\n" %
+                               (self.__getpos(exception),
+                                exception.getMessage()))
+
+    def error(self, exception):
+        if self._level <= 1:
+            self._outfile.write("ERROR in %s: %s\n" %
+                               (self.__getpos(exception),
+                                exception.getMessage()))
+
+    def fatalError(self, exception):
+        if self._level <= 2:
+            self._outfile.write("FATAL ERROR in %s: %s\n" %
+                               (self.__getpos(exception),
+                                exception.getMessage()))
+
+    def __getpos(self, exception):
+        if isinstance(exception, _exceptions.SAXParseException):
+            return "%s:%s:%s" % (exception.getSystemId(),
+                                 exception.getLineNumber(),
+                                 exception.getColumnNumber())
+        else:
+            return "<unknown>"
+
+# --- ErrorRaiser
+
+class ErrorRaiser:
+    "A simple class that just raises the exceptions it is passed."
+
+    def __init__(self, level = 0):
+        self._level = level
+
+    def error(self, exception):
+        if self._level <= 1:
+            raise exception
+
+    def fatalError(self, exception):
+        if self._level <= 2:
+            raise exception
+
+    def warning(self, exception):
+        if self._level <= 0:
+            raise exception
+
+# --- AttributesImpl now lives in xmlreader
+from xmlreader import AttributesImpl
+
+# --- XMLGenerator is the SAX2 ContentHandler for writing back XML
+import codecs
+
+def _outputwrapper(stream,encoding):
+    writerclass = codecs.lookup(encoding)[3]
+    return writerclass(stream)
+
+if hasattr(codecs, "register_error"):
+    def writetext(stream, text, entities={}):
+        stream.errors = "xmlcharrefreplace"
+        stream.write(escape(text, entities))
+        stream.errors = "strict"
+else:
+    def writetext(stream, text, entities={}):
+        text = escape(text, entities)
+        try:
+            stream.write(text)
+        except UnicodeError:
+            for c in text:
+                try:
+                    stream.write(c)
+                except UnicodeError:
+                    stream.write("&#%d;" % ord(c))
+
+def writeattr(stream, text):
+    countdouble = text.count('"')
+    if countdouble:
+        countsingle = text.count("'")
+        if countdouble <= countsingle:
+            entities = {'"': "&quot;"}
+            quote = '"'
+        else:
+            entities = {"'": "&apos;"}
+            quote = "'"
+    else:
+        entities = {}
+        quote = '"'
+    stream.write(quote)
+    writetext(stream, text, entities)
+    stream.write(quote)
+
+
+class XMLGenerator(handler.ContentHandler):
+    GENERATED_PREFIX = "xml.sax.saxutils.prefix%s"
+
+    def __init__(self, out=None, encoding="iso-8859-1"):
+        if out is None:
+            import sys
+            out = sys.stdout
+        handler.ContentHandler.__init__(self)
+        self._out = _outputwrapper(out,encoding)
+        self._ns_contexts = [{}] # contains uri -> prefix dicts
+        self._current_context = self._ns_contexts[-1]
+        self._undeclared_ns_maps = []
+        self._encoding = encoding
+        self._generated_prefix_ctr = 0
+        return
+
+    # ContentHandler methods
+
+    def startDocument(self):
+        self._out.write('<?xml version="1.0" encoding="%s"?>\n' %
+                        self._encoding)
+
+    def startPrefixMapping(self, prefix, uri):
+        self._ns_contexts.append(self._current_context.copy())
+        self._current_context[uri] = prefix
+        self._undeclared_ns_maps.append((prefix, uri))
+
+    def endPrefixMapping(self, prefix):
+        self._current_context = self._ns_contexts[-1]
+        del self._ns_contexts[-1]
+
+    def startElement(self, name, attrs):
+        self._out.write('<' + name)
+        for (name, value) in attrs.items():
+            self._out.write(' %s=' % name)
+            writeattr(self._out, value)
+        self._out.write('>')
+
+    def endElement(self, name):
+        self._out.write('</%s>' % name)
+
+    def startElementNS(self, name, qname, attrs):
+        if name[0] is None:
+            name = name[1]
+        elif self._current_context[name[0]] is None:
+            # default namespace
+            name = name[1]
+        else:
+            name = self._current_context[name[0]] + ":" + name[1]
+        self._out.write('<' + name)
+
+        for k,v in self._undeclared_ns_maps:
+            if k is None:
+                self._out.write(' xmlns="%s"' % (v or ''))
+            else:
+                self._out.write(' xmlns:%s="%s"' % (k,v))
+        self._undeclared_ns_maps = []
+
+        for (name, value) in attrs.items():
+            if name[0] is None:
+                name = name[1]
+            elif self._current_context[name[0]] is None:
+                # default namespace
+                #If an attribute has a nsuri but not a prefix, we must
+                #create a prefix and add a nsdecl
+                prefix = self.GENERATED_PREFIX % self._generated_prefix_ctr
+                self._generated_prefix_ctr = self._generated_prefix_ctr + 1
+                name = prefix + ':' + name[1]
+                self._out.write(' xmlns:%s=%s' % (prefix, quoteattr(name[0])))
+                self._current_context[name[0]] = prefix
+            else:
+                name = self._current_context[name[0]] + ":" + name[1]
+            self._out.write(' %s=' % name)
+            writeattr(self._out, value)
+        self._out.write('>')
+
+    def endElementNS(self, name, qname):
+        # XXX: if qname is not None, we better use it.
+        # Python 2.0b2 requires us to use the recorded prefix for
+        # name[0], though
+        if name[0] is None:
+            qname = name[1]
+        elif self._current_context[name[0]] is None:
+            qname = name[1]
+        else:
+            qname = self._current_context[name[0]] + ":" + name[1]
+        self._out.write('</%s>' % qname)
+
+    def characters(self, content):
+        writetext(self._out, content)
+
+    def ignorableWhitespace(self, content):
+        self._out.write(content)
+
+    def processingInstruction(self, target, data):
+        self._out.write('<?%s %s?>' % (target, data))
+
+
+class LexicalXMLGenerator(XMLGenerator, saxlib.LexicalHandler):
+    """A XMLGenerator that also supports the LexicalHandler interface"""
+
+    def __init__(self, out=None, encoding="iso-8859-1"):
+        XMLGenerator.__init__(self, out, encoding)
+        self._in_cdata = 0
+
+    def characters(self, content):
+        if self._in_cdata:
+            self._out.write(content.replace(']]>', ']]>]]&gt;<![CDATA['))
+        else:
+            self._out.write(escape(content))
+
+    # LexicalHandler methods
+    # (we only support the most important ones and inherit the rest)
+
+    def startDTD(self, name, public_id, system_id):
+        self._out.write('<!DOCTYPE %s' % name)
+        if public_id:
+            self._out.write(' PUBLIC %s %s' % (
+                quoteattr(public_id or ""), quoteattr(system_id or "")
+            ))
+        elif system_id:
+            self._out.write(' SYSTEM %s' % quoteattr(system_id or ""))
+
+    def endDTD(self):
+        self._out.write('>')
+
+    def comment(self, content):
+        self._out.write('<!--')
+        self._out.write(content)
+        self._out.write('-->')
+
+    def startCDATA(self):
+        self._in_cdata = 1
+        self._out.write('<![CDATA[')
+
+    def endCDATA(self):
+        self._in_cdata = 0
+        self._out.write(']]>')
+
+
+# --- ContentGenerator is the SAX1 DocumentHandler for writing back XML
+class ContentGenerator(XMLGenerator):
+
+    def characters(self, str, start, end):
+        # In SAX1, characters receives start and end; in SAX2, it receives
+        # a string. For plain strings, we may want to use a buffer object.
+        return XMLGenerator.characters(self, str[start:start+end])
+
+# --- XMLFilterImpl
+class XMLFilterBase(saxlib.XMLFilter):
+    """This class is designed to sit between an XMLReader and the
+    client application's event handlers.  By default, it does nothing
+    but pass requests up to the reader and events on to the handlers
+    unmodified, but subclasses can override specific methods to modify
+    the event stream or the configuration requests as they pass
+    through."""
+
+    # ErrorHandler methods
+
+    def error(self, exception):
+        self._err_handler.error(exception)
+
+    def fatalError(self, exception):
+        self._err_handler.fatalError(exception)
+
+    def warning(self, exception):
+        self._err_handler.warning(exception)
+
+    # ContentHandler methods
+
+    def setDocumentLocator(self, locator):
+        self._cont_handler.setDocumentLocator(locator)
+
+    def startDocument(self):
+        self._cont_handler.startDocument()
+
+    def endDocument(self):
+        self._cont_handler.endDocument()
+
+    def startPrefixMapping(self, prefix, uri):
+        self._cont_handler.startPrefixMapping(prefix, uri)
+
+    def endPrefixMapping(self, prefix):
+        self._cont_handler.endPrefixMapping(prefix)
+
+    def startElement(self, name, attrs):
+        self._cont_handler.startElement(name, attrs)
+
+    def endElement(self, name):
+        self._cont_handler.endElement(name)
+
+    def startElementNS(self, name, qname, attrs):
+        self._cont_handler.startElementNS(name, qname, attrs)
+
+    def endElementNS(self, name, qname):
+        self._cont_handler.endElementNS(name, qname)
+
+    def characters(self, content):
+        self._cont_handler.characters(content)
+
+    def ignorableWhitespace(self, chars):
+        self._cont_handler.ignorableWhitespace(chars)
+
+    def processingInstruction(self, target, data):
+        self._cont_handler.processingInstruction(target, data)
+
+    def skippedEntity(self, name):
+        self._cont_handler.skippedEntity(name)
+
+    # DTDHandler methods
+
+    def notationDecl(self, name, publicId, systemId):
+        self._dtd_handler.notationDecl(name, publicId, systemId)
+
+    def unparsedEntityDecl(self, name, publicId, systemId, ndata):
+        self._dtd_handler.unparsedEntityDecl(name, publicId, systemId, ndata)
+
+    # EntityResolver methods
+
+    def resolveEntity(self, publicId, systemId):
+        return self._ent_handler.resolveEntity(publicId, systemId)
+
+    # XMLReader methods
+
+    def parse(self, source):
+        self._parent.setContentHandler(self)
+        self._parent.setErrorHandler(self)
+        self._parent.setEntityResolver(self)
+        self._parent.setDTDHandler(self)
+        self._parent.parse(source)
+
+    def setLocale(self, locale):
+        self._parent.setLocale(locale)
+
+    def getFeature(self, name):
+        return self._parent.getFeature(name)
+
+    def setFeature(self, name, state):
+        self._parent.setFeature(name, state)
+
+    def getProperty(self, name):
+        return self._parent.getProperty(name)
+
+    def setProperty(self, name, value):
+        self._parent.setProperty(name, value)
+
+# FIXME: remove this backward compatibility hack when not needed anymore
+XMLFilterImpl = XMLFilterBase
+
+# --- BaseIncrementalParser
+
+class BaseIncrementalParser(xmlreader.IncrementalParser):
+    """This class implements the parse method of the XMLReader
+    interface using the feed, close and reset methods of the
+    IncrementalParser interface as a convenience to SAX 2.0 driver
+    writers."""
+
+    def parse(self, source):
+        source = prepare_input_source(source)
+        self.prepareParser(source)
+
+        self._cont_handler.startDocument()
+
+        # FIXME: what about char-stream?
+        inf = source.getByteStream()
+        buffer = inf.read(16384)
+        while buffer != "":
+            self.feed(buffer)
+            buffer = inf.read(16384)
+
+        self.close()
+        self.reset()
+
+        self._cont_handler.endDocument()
+
+    def prepareParser(self, source):
+        """This method is called by the parse implementation to allow
+        the SAX 2.0 driver to prepare itself for parsing."""
+        raise NotImplementedError("prepareParser must be overridden!")
+
+# --- Utility functions
+
+def prepare_input_source(source, base = ""):
+    """This function takes an InputSource and an optional base URL and
+    returns a fully resolved InputSource object ready for reading."""
+
+    if type(source) in _StringTypes:
+        source = xmlreader.InputSource(source)
+    elif hasattr(source, "read"):
+        f = source
+        source = xmlreader.InputSource()
+        source.setByteStream(f)
+        if hasattr(f, "name"):
+            source.setSystemId(absolute_system_id(f.name, base))
+
+    if source.getByteStream() is None:
+        sysid = absolute_system_id(source.getSystemId(), base)
+        source.setSystemId(sysid)
+        f = urllib2.urlopen(sysid)
+        source.setByteStream(f)
+
+    return source
+
+
+def absolute_system_id(sysid, base=''):
+    if os.path.exists(sysid):
+        sysid = 'file:%s' % os.path.abspath(sysid)
+    elif base:
+        sysid = Absolutize(sysid, base)
+    assert IsAbsolute(sysid)
+    return MakeUrllibSafe(sysid)
+
+# ===========================================================================
+#
+# DEPRECATED SAX 1.0 CLASSES
+#
+# ===========================================================================
+
+# --- AttributeMap
+
+class AttributeMap:
+    """An implementation of AttributeList that takes an (attr,val) hash
+    and uses it to implement the AttributeList interface."""
+
+    def __init__(self, map):
+        self.map=map
+
+    def getLength(self):
+        return len(self.map.keys())
+
+    def getName(self, i):
+        try:
+            return self.map.keys()[i]
+        except IndexError,e:
+            return None
+
+    def getType(self, i):
+        return "CDATA"
+
+    def getValue(self, i):
+        try:
+            if type(i)==types.IntType:
+                return self.map[self.getName(i)]
+            else:
+                return self.map[i]
+        except KeyError,e:
+            return None
+
+    def __len__(self):
+        return len(self.map)
+
+    def __getitem__(self, key):
+        if type(key)==types.IntType:
+            return self.map.keys()[key]
+        else:
+            return self.map[key]
+
+    def items(self):
+        return self.map.items()
+
+    def keys(self):
+        return self.map.keys()
+
+    def has_key(self,key):
+        return self.map.has_key(key)
+
+    def get(self, key, alternative=None):
+        return self.map.get(key, alternative)
+
+    def copy(self):
+        return AttributeMap(self.map.copy())
+
+    def values(self):
+        return self.map.values()
+
+# --- Event broadcasting object
+
+class EventBroadcaster:
+    """Takes a list of objects and forwards any method calls received
+    to all objects in the list. The attribute list holds the list and
+    can freely be modified by clients."""
+
+    class Event:
+        "Helper objects that represent event methods."
+
+        def __init__(self,list,name):
+            self.list=list
+            self.name=name
+
+        def __call__(self,*rest):
+            for obj in self.list:
+                apply(getattr(obj,self.name), rest)
+
+    def __init__(self,list):
+        self.list=list
+
+    def __getattr__(self,name):
+        return self.Event(self.list,name)
+
+    def __repr__(self):
+        return "<EventBroadcaster instance at %d>" % id(self)
+
+# --- ESIS document handler
+import saxlib
+class ESISDocHandler(saxlib.HandlerBase):
+    "A SAX document handler that produces naive ESIS output."
+
+    def __init__(self,writer=sys.stdout):
+        self.writer=writer
+
+    def processingInstruction (self,target, remainder):
+        """Receive an event signalling that a processing instruction
+        has been found."""
+        self.writer.write("?"+target+" "+remainder+"\n")
+
+    def startElement(self,name,amap):
+        "Receive an event signalling the start of an element."
+        self.writer.write("("+name+"\n")
+        for a_name in amap.keys():
+            self.writer.write("A"+a_name+" "+amap[a_name]+"\n")
+
+    def endElement(self,name):
+        "Receive an event signalling the end of an element."
+        self.writer.write(")"+name+"\n")
+
+    def characters(self,data,start_ix,length):
+        "Receive an event signalling that character data has been found."
+        self.writer.write("-"+data[start_ix:start_ix+length]+"\n")
+
+# --- XML canonizer
+
+class Canonizer(saxlib.HandlerBase):
+    "A SAX document handler that produces canonized XML output."
+
+    def __init__(self,writer=sys.stdout):
+        self.elem_level=0
+        self.writer=writer
+
+    def processingInstruction (self,target, remainder):
+        if not target=="xml":
+            self.writer.write("<?"+target+" "+remainder+"?>")
+
+    def startElement(self,name,amap):
+        self.writer.write("<"+name)
+
+        a_names=amap.keys()
+        a_names.sort()
+
+        for a_name in a_names:
+            self.writer.write(" "+a_name+"=\"")
+            self.write_data(amap[a_name])
+            self.writer.write("\"")
+        self.writer.write(">")
+        self.elem_level=self.elem_level+1
+
+    def endElement(self,name):
+        self.writer.write("</"+name+">")
+        self.elem_level=self.elem_level-1
+
+    def ignorableWhitespace(self,data,start_ix,length):
+        self.characters(data,start_ix,length)
+
+    def characters(self,data,start_ix,length):
+        if self.elem_level>0:
+            self.write_data(data[start_ix:start_ix+length])
+
+    def write_data(self,data):
+        "Writes datachars to writer."
+        data=data.replace("&","&amp;")
+        data=data.replace("<","&lt;")
+        data=data.replace("\"","&quot;")
+        data=data.replace(">","&gt;")
+        data=data.replace(chr(9),"&#9;")
+        data=data.replace(chr(10),"&#10;")
+        data=data.replace(chr(13),"&#13;")
+        self.writer.write(data)
+
+# --- mllib
+
+class mllib:
+    """A re-implementation of the htmllib, sgmllib and xmllib interfaces as a
+    SAX DocumentHandler."""
+
+# Unsupported:
+# - setnomoretags
+# - setliteral
+# - translate_references
+# - handle_xml
+# - handle_doctype
+# - handle_charref
+# - handle_entityref
+# - handle_comment
+# - handle_cdata
+# - tag_attributes
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        import saxexts # only used here
+        self.parser=saxexts.XMLParserFactory.make_parser()
+        self.handler=mllib.Handler(self.parser,self)
+        self.handler.reset()
+
+    def feed(self,data):
+        self.parser.feed(data)
+
+    def close(self):
+        self.parser.close()
+
+    def get_stack(self):
+        return self.handler.get_stack()
+
+    # --- Handler methods (to be overridden)
+
+    def handle_starttag(self,name,method,atts):
+        method(atts)
+
+    def handle_endtag(self,name,method):
+        method()
+
+    def handle_data(self,data):
+        pass
+
+    def handle_proc(self,target,data):
+        pass
+
+    def unknown_starttag(self,name,atts):
+        pass
+
+    def unknown_endtag(self,name):
+        pass
+
+    def syntax_error(self,message):
+        pass
+
+    # --- The internal handler class
+
+    class Handler(saxlib.DocumentHandler,saxlib.ErrorHandler):
+        """An internal class to handle SAX events and translate them to mllib
+        events."""
+
+        def __init__(self,driver,handler):
+            self.driver=driver
+            self.driver.setDocumentHandler(self)
+            self.driver.setErrorHandler(self)
+            self.handler=handler
+            self.reset()
+
+        def get_stack(self):
+            return self.stack
+
+        def reset(self):
+            self.stack=[]
+
+        # --- DocumentHandler methods
+
+        def characters(self, ch, start, length):
+            self.handler.handle_data(ch[start:start+length])
+
+        def endElement(self, name):
+            if hasattr(self.handler,"end_"+name):
+                self.handler.handle_endtag(name,
+                                          getattr(self.handler,"end_"+name))
+            else:
+                self.handler.unknown_endtag(name)
+
+            del self.stack[-1]
+
+        def ignorableWhitespace(self, ch, start, length):
+            self.handler.handle_data(ch[start:start+length])
+
+        def processingInstruction(self, target, data):
+            self.handler.handle_proc(target,data)
+
+        def startElement(self, name, atts):
+            self.stack.append(name)
+
+            if hasattr(self.handler,"start_"+name):
+                self.handler.handle_starttag(name,
+                                            getattr(self.handler,
+                                                    "start_"+name),
+                                             atts)
+            else:
+                self.handler.unknown_starttag(name,atts)
+
+        # --- ErrorHandler methods
+
+        def error(self, exception):
+            self.handler.syntax_error(str(exception))
+
+        def fatalError(self, exception):
+            raise RuntimeError(str(exception))

plugins/Jython/Lib/xml/sax/xmlreader.py

@@ -0,0 +1,378 @@
+"""An XML Reader is the SAX 2 name for an XML parser. XML Parsers
+should be based on this code. """
+
+import handler
+
+from _exceptions import SAXNotSupportedException, SAXNotRecognizedException
+
+
+# ===== XMLREADER =====
+
+class XMLReader:
+    """Interface for reading an XML document using callbacks.
+
+    XMLReader is the interface that an XML parser's SAX2 driver must
+    implement. This interface allows an application to set and query
+    features and properties in the parser, to register event handlers
+    for document processing, and to initiate a document parse.
+
+    All SAX interfaces are assumed to be synchronous: the parse
+    methods must not return until parsing is complete, and readers
+    must wait for an event-handler callback to return before reporting
+    the next event."""
+
+    def __init__(self):
+        self._cont_handler = handler.ContentHandler()
+        self._dtd_handler = handler.DTDHandler()
+        self._ent_handler = handler.EntityResolver()
+        self._err_handler = handler.ErrorHandler()
+
+    def parse(self, source):
+        "Parse an XML document from a system identifier or an InputSource."
+        raise NotImplementedError("This method must be implemented!")
+
+    def getContentHandler(self):
+        "Returns the current ContentHandler."
+        return self._cont_handler
+
+    def setContentHandler(self, handler):
+        "Registers a new object to receive document content events."
+        self._cont_handler = handler
+
+    def getDTDHandler(self):
+        "Returns the current DTD handler."
+        return self._dtd_handler
+
+    def setDTDHandler(self, handler):
+        "Register an object to receive basic DTD-related events."
+        self._dtd_handler = handler
+
+    def getEntityResolver(self):
+        "Returns the current EntityResolver."
+        return self._ent_handler
+
+    def setEntityResolver(self, resolver):
+        "Register an object to resolve external entities."
+        self._ent_handler = resolver
+
+    def getErrorHandler(self):
+        "Returns the current ErrorHandler."
+        return self._err_handler
+
+    def setErrorHandler(self, handler):
+        "Register an object to receive error-message events."
+        self._err_handler = handler
+
+    def setLocale(self, locale):
+        """Allow an application to set the locale for errors and warnings.
+
+        SAX parsers are not required to provide localization for errors
+        and warnings; if they cannot support the requested locale,
+        however, they must throw a SAX exception. Applications may
+        request a locale change in the middle of a parse."""
+        raise SAXNotSupportedException("Locale support not implemented")
+
+    def getFeature(self, name):
+        "Looks up and returns the state of a SAX2 feature."
+        raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
+
+    def setFeature(self, name, state):
+        "Sets the state of a SAX2 feature."
+        raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
+
+    def getProperty(self, name):
+        "Looks up and returns the value of a SAX2 property."
+        raise SAXNotRecognizedException("Property '%s' not recognized" % name)
+
+    def setProperty(self, name, value):
+        "Sets the value of a SAX2 property."
+        raise SAXNotRecognizedException("Property '%s' not recognized" % name)
+
+class IncrementalParser(XMLReader):
+    """This interface adds three extra methods to the XMLReader
+    interface that allow XML parsers to support incremental
+    parsing. Support for this interface is optional, since not all
+    underlying XML parsers support this functionality.
+
+    When the parser is instantiated it is ready to begin accepting
+    data from the feed method immediately. After parsing has been
+    finished with a call to close the reset method must be called to
+    make the parser ready to accept new data, either from feed or
+    using the parse method.
+
+    Note that these methods must _not_ be called during parsing, that
+    is, after parse has been called and before it returns.
+
+    By default, the class also implements the parse method of the XMLReader
+    interface using the feed, close and reset methods of the
+    IncrementalParser interface as a convenience to SAX 2.0 driver
+    writers."""
+
+    def __init__(self, bufsize=2**16):
+        self._bufsize = bufsize
+        XMLReader.__init__(self)
+
+    def parse(self, source):
+        import saxutils
+        source = saxutils.prepare_input_source(source)
+
+        self.prepareParser(source)
+        file = source.getByteStream()
+        buffer = file.read(self._bufsize)
+        while buffer != "":
+            self.feed(buffer)
+            buffer = file.read(self._bufsize)
+        self.close()
+
+    def feed(self, data):
+        """This method gives the raw XML data in the data parameter to
+        the parser and makes it parse the data, emitting the
+        corresponding events. It is allowed for XML constructs to be
+        split across several calls to feed.
+
+        feed may raise SAXException."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def prepareParser(self, source):
+        """This method is called by the parse implementation to allow
+        the SAX 2.0 driver to prepare itself for parsing."""
+        raise NotImplementedError("prepareParser must be overridden!")
+
+    def close(self):
+        """This method is called when the entire XML document has been
+        passed to the parser through the feed method, to notify the
+        parser that there are no more data. This allows the parser to
+        do the final checks on the document and empty the internal
+        data buffer.
+
+        The parser will not be ready to parse another document until
+        the reset method has been called.
+
+        close may raise SAXException."""
+        raise NotImplementedError("This method must be implemented!")
+
+    def reset(self):
+        """This method is called after close has been called to reset
+        the parser so that it is ready to parse new documents. The
+        results of calling parse or feed after close without calling
+        reset are undefined."""
+        raise NotImplementedError("This method must be implemented!")
+
+# ===== LOCATOR =====
+
+class Locator:
+    """Interface for associating a SAX event with a document
+    location. A locator object will return valid results only during
+    calls to DocumentHandler methods; at any other time, the
+    results are unpredictable."""
+
+    def getColumnNumber(self):
+        "Return the column number where the current event ends."
+        return -1
+
+    def getLineNumber(self):
+        "Return the line number where the current event ends."
+        return -1
+
+    def getPublicId(self):
+        "Return the public identifier for the current event."
+        return None
+
+    def getSystemId(self):
+        "Return the system identifier for the current event."
+        return None
+
+# ===== INPUTSOURCE =====
+
+class InputSource:
+    """Encapsulation of the information needed by the XMLReader to
+    read entities.
+
+    This class may include information about the public identifier,
+    system identifier, byte stream (possibly with character encoding
+    information) and/or the character stream of an entity.
+
+    Applications will create objects of this class for use in the
+    XMLReader.parse method and for returning from
+    EntityResolver.resolveEntity.
+
+    An InputSource belongs to the application, the XMLReader is not
+    allowed to modify InputSource objects passed to it from the
+    application, although it may make copies and modify those."""
+
+    def __init__(self, system_id = None):
+        self.__system_id = system_id
+        self.__public_id = None
+        self.__encoding  = None
+        self.__bytefile  = None
+        self.__charfile  = None
+
+    def setPublicId(self, public_id):
+        "Sets the public identifier of this InputSource."
+        self.__public_id = public_id
+
+    def getPublicId(self):
+        "Returns the public identifier of this InputSource."
+        return self.__public_id
+
+    def setSystemId(self, system_id):
+        "Sets the system identifier of this InputSource."
+        self.__system_id = system_id
+
+    def getSystemId(self):
+        "Returns the system identifier of this InputSource."
+        return self.__system_id
+
+    def setEncoding(self, encoding):
+        """Sets the character encoding of this InputSource.
+
+        The encoding must be a string acceptable for an XML encoding
+        declaration (see section 4.3.3 of the XML recommendation).
+
+        The encoding attribute of the InputSource is ignored if the
+        InputSource also contains a character stream."""
+        self.__encoding = encoding
+
+    def getEncoding(self):
+        "Get the character encoding of this InputSource."
+        return self.__encoding
+
+    def setByteStream(self, bytefile):
+        """Set the byte stream (a Python file-like object which does
+        not perform byte-to-character conversion) for this input
+        source.
+
+        The SAX parser will ignore this if there is also a character
+        stream specified, but it will use a byte stream in preference
+        to opening a URI connection itself.
+
+        If the application knows the character encoding of the byte
+        stream, it should set it with the setEncoding method."""
+        self.__bytefile = bytefile
+
+    def getByteStream(self):
+        """Get the byte stream for this input source.
+
+        The getEncoding method will return the character encoding for
+        this byte stream, or None if unknown."""
+        return self.__bytefile
+
+    def setCharacterStream(self, charfile):
+        """Set the character stream for this input source. (The stream
+        must be a Python 2.0 Unicode-wrapped file-like that performs
+        conversion to Unicode strings.)
+
+        If there is a character stream specified, the SAX parser will
+        ignore any byte stream and will not attempt to open a URI
+        connection to the system identifier."""
+        self.__charfile = charfile
+
+    def getCharacterStream(self):
+        "Get the character stream for this input source."
+        return self.__charfile
+
+# ===== ATTRIBUTESIMPL =====
+
+class AttributesImpl:
+
+    def __init__(self, attrs):
+        """Non-NS-aware implementation.
+
+        attrs should be of the form {name : value}."""
+        self._attrs = attrs
+
+    def getLength(self):
+        return len(self._attrs)
+
+    def getType(self, name):
+        return "CDATA"
+
+    def getValue(self, name):
+        return self._attrs[name]
+
+    def getValueByQName(self, name):
+        return self._attrs[name]
+
+    def getNameByQName(self, name):
+        if not self._attrs.has_key(name):
+            raise KeyError, name
+        return name
+
+    def getQNameByName(self, name):
+        if not self._attrs.has_key(name):
+            raise KeyError, name
+        return name
+
+    def getNames(self):
+        return self._attrs.keys()
+
+    def getQNames(self):
+        return self._attrs.keys()
+
+    def __len__(self):
+        return len(self._attrs)
+
+    def __getitem__(self, name):
+        return self._attrs[name]
+
+    def keys(self):
+        return self._attrs.keys()
+
+    def has_key(self, name):
+        return self._attrs.has_key(name)
+
+    def get(self, name, alternative=None):
+        return self._attrs.get(name, alternative)
+
+    def copy(self):
+        return self.__class__(self._attrs)
+
+    def items(self):
+        return self._attrs.items()
+
+    def values(self):
+        return self._attrs.values()
+
+# ===== ATTRIBUTESNSIMPL =====
+
+class AttributesNSImpl(AttributesImpl):
+
+    def __init__(self, attrs, qnames):
+        """NS-aware implementation.
+
+        attrs should be of the form {(ns_uri, lname): value, ...}.
+        qnames of the form {(ns_uri, lname): qname, ...}."""
+        self._attrs = attrs
+        self._qnames = qnames
+
+    def getValueByQName(self, name):
+        for (nsname, qname) in self._qnames.items():
+            if qname == name:
+                return self._attrs[nsname]
+
+        raise KeyError, name
+
+    def getNameByQName(self, name):
+        for (nsname, qname) in self._qnames.items():
+            if qname == name:
+                return nsname
+
+        raise KeyError, name
+
+    def getQNameByName(self, name):
+        return self._qnames[name]
+
+    def getQNames(self):
+        return self._qnames.values()
+
+    def copy(self):
+        return self.__class__(self._attrs, self._qnames)
+
+
+def _test():
+    XMLReader()
+    IncrementalParser()
+    Locator()
+
+if __name__ == "__main__":
+    _test()