[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Lib / xmllib.py

"""A parser for XML, using the derived class as static DTD."""\r
\r
# Author: Sjoerd Mullender.\r
\r
import re\r
import string\r
\r
import warnings\r
warnings.warn("The xmllib module is obsolete.  Use xml.sax instead.",\r
              DeprecationWarning, 2)\r
del warnings\r
\r
version = '0.3'\r
\r
class Error(RuntimeError):\r
    pass\r
\r
# Regular expressions used for parsing\r
\r
_S = '[ \t\r\n]+'                       # white space\r
_opS = '[ \t\r\n]*'                     # optional white space\r
_Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'    # valid XML name\r
_QStr = "(?:'[^']*'|\"[^\"]*\")"        # quoted XML string\r
illegal = re.compile('[^\t\r\n -\176\240-\377]') # illegal chars in content\r
interesting = re.compile('[]&<]')\r
\r
amp = re.compile('&')\r
ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')\r
entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')\r
charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')\r
space = re.compile(_S + '$')\r
newline = re.compile('\n')\r
\r
attrfind = re.compile(\r
    _S + '(?P<name>' + _Name + ')'\r
    '(' + _opS + '=' + _opS +\r
    '(?P<value>'+_QStr+'|[-a-zA-Z0-9.:+*%?!\(\)_#=~]+))?')\r
starttagopen = re.compile('<' + _Name)\r
starttagend = re.compile(_opS + '(?P<slash>/?)>')\r
starttagmatch = re.compile('<(?P<tagname>'+_Name+')'\r
                      '(?P<attrs>(?:'+attrfind.pattern+')*)'+\r
                      starttagend.pattern)\r
endtagopen = re.compile('</')\r
endbracket = re.compile(_opS + '>')\r
endbracketfind = re.compile('(?:[^>\'"]|'+_QStr+')*>')\r
tagfind = re.compile(_Name)\r
cdataopen = re.compile(r'<!\[CDATA\[')\r
cdataclose = re.compile(r'\]\]>')\r
# this matches one of the following:\r
# SYSTEM SystemLiteral\r
# PUBLIC PubidLiteral SystemLiteral\r
_SystemLiteral = '(?P<%s>'+_QStr+')'\r
_PublicLiteral = '(?P<%s>"[-\'\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|' \\r
                        "'[-\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*')"\r
_ExternalId = '(?:SYSTEM|' \\r
                 'PUBLIC'+_S+_PublicLiteral%'pubid'+ \\r
              ')'+_S+_SystemLiteral%'syslit'\r
doctype = re.compile('<!DOCTYPE'+_S+'(?P<name>'+_Name+')'\r
                     '(?:'+_S+_ExternalId+')?'+_opS)\r
xmldecl = re.compile('<\?xml'+_S+\r
                     'version'+_opS+'='+_opS+'(?P<version>'+_QStr+')'+\r
                     '(?:'+_S+'encoding'+_opS+'='+_opS+\r
                        "(?P<encoding>'[A-Za-z][-A-Za-z0-9._]*'|"\r
                        '"[A-Za-z][-A-Za-z0-9._]*"))?'\r
                     '(?:'+_S+'standalone'+_opS+'='+_opS+\r
                        '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?'+\r
                     _opS+'\?>')\r
procopen = re.compile(r'<\?(?P<proc>' + _Name + ')' + _opS)\r
procclose = re.compile(_opS + r'\?>')\r
commentopen = re.compile('<!--')\r
commentclose = re.compile('-->')\r
doubledash = re.compile('--')\r
attrtrans = string.maketrans(' \r\n\t', '    ')\r
\r
# definitions for XML namespaces\r
_NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'    # XML Name, minus the ":"\r
ncname = re.compile(_NCName + '$')\r
qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?' # optional prefix\r
                   '(?P<local>' + _NCName + ')$')\r
\r
xmlns = re.compile('xmlns(?::(?P<ncname>'+_NCName+'))?$')\r
\r
# XML parser base class -- find tags and call handler functions.\r
# Usage: p = XMLParser(); p.feed(data); ...; p.close().\r
# The dtd is defined by deriving a class which defines methods with\r
# special names to handle tags: start_foo and end_foo to handle <foo>\r
# and </foo>, respectively.  The data between tags is passed to the\r
# parser by calling self.handle_data() with some data as argument (the\r
# data may be split up in arbitrary chunks).\r
\r
class XMLParser:\r
    attributes = {}                     # default, to be overridden\r
    elements = {}                       # default, to be overridden\r
\r
    # parsing options, settable using keyword args in __init__\r
    __accept_unquoted_attributes = 0\r
    __accept_missing_endtag_name = 0\r
    __map_case = 0\r
    __accept_utf8 = 0\r
    __translate_attribute_references = 1\r
\r
    # Interface -- initialize and reset this instance\r
    def __init__(self, **kw):\r
        self.__fixed = 0\r
        if 'accept_unquoted_attributes' in kw:\r
            self.__accept_unquoted_attributes = kw['accept_unquoted_attributes']\r
        if 'accept_missing_endtag_name' in kw:\r
            self.__accept_missing_endtag_name = kw['accept_missing_endtag_name']\r
        if 'map_case' in kw:\r
            self.__map_case = kw['map_case']\r
        if 'accept_utf8' in kw:\r
            self.__accept_utf8 = kw['accept_utf8']\r
        if 'translate_attribute_references' in kw:\r
            self.__translate_attribute_references = kw['translate_attribute_references']\r
        self.reset()\r
\r
    def __fixelements(self):\r
        self.__fixed = 1\r
        self.elements = {}\r
        self.__fixdict(self.__dict__)\r
        self.__fixclass(self.__class__)\r
\r
    def __fixclass(self, kl):\r
        self.__fixdict(kl.__dict__)\r
        for k in kl.__bases__:\r
            self.__fixclass(k)\r
\r
    def __fixdict(self, dict):\r
        for key in dict.keys():\r
            if key[:6] == 'start_':\r
                tag = key[6:]\r
                start, end = self.elements.get(tag, (None, None))\r
                if start is None:\r
                    self.elements[tag] = getattr(self, key), end\r
            elif key[:4] == 'end_':\r
                tag = key[4:]\r
                start, end = self.elements.get(tag, (None, None))\r
                if end is None:\r
                    self.elements[tag] = start, getattr(self, key)\r
\r
    # Interface -- reset this instance.  Loses all unprocessed data\r
    def reset(self):\r
        self.rawdata = ''\r
        self.stack = []\r
        self.nomoretags = 0\r
        self.literal = 0\r
        self.lineno = 1\r
        self.__at_start = 1\r
        self.__seen_doctype = None\r
        self.__seen_starttag = 0\r
        self.__use_namespaces = 0\r
        self.__namespaces = {'xml':None}   # xml is implicitly declared\r
        # backward compatibility hack: if elements not overridden,\r
        # fill it in ourselves\r
        if self.elements is XMLParser.elements:\r
            self.__fixelements()\r
\r
    # For derived classes only -- enter literal mode (CDATA) till EOF\r
    def setnomoretags(self):\r
        self.nomoretags = self.literal = 1\r
\r
    # For derived classes only -- enter literal mode (CDATA)\r
    def setliteral(self, *args):\r
        self.literal = 1\r
\r
    # Interface -- feed some data to the parser.  Call this as\r
    # often as you want, with as little or as much text as you\r
    # want (may include '\n').  (This just saves the text, all the\r
    # processing is done by goahead().)\r
    def feed(self, data):\r
        self.rawdata = self.rawdata + data\r
        self.goahead(0)\r
\r
    # Interface -- handle the remaining data\r
    def close(self):\r
        self.goahead(1)\r
        if self.__fixed:\r
            self.__fixed = 0\r
            # remove self.elements so that we don't leak\r
            del self.elements\r
\r
    # Interface -- translate references\r
    def translate_references(self, data, all = 1):\r
        if not self.__translate_attribute_references:\r
            return data\r
        i = 0\r
        while 1:\r
            res = amp.search(data, i)\r
            if res is None:\r
                return data\r
            s = res.start(0)\r
            res = ref.match(data, s)\r
            if res is None:\r
                self.syntax_error("bogus `&'")\r
                i = s+1\r
                continue\r
            i = res.end(0)\r
            str = res.group(1)\r
            rescan = 0\r
            if str[0] == '#':\r
                if str[1] == 'x':\r
                    str = chr(int(str[2:], 16))\r
                else:\r
                    str = chr(int(str[1:]))\r
                if data[i - 1] != ';':\r
                    self.syntax_error("`;' missing after char reference")\r
                    i = i-1\r
            elif all:\r
                if str in self.entitydefs:\r
                    str = self.entitydefs[str]\r
                    rescan = 1\r
                elif data[i - 1] != ';':\r
                    self.syntax_error("bogus `&'")\r
                    i = s + 1 # just past the &\r
                    continue\r
                else:\r
                    self.syntax_error("reference to unknown entity `&%s;'" % str)\r
                    str = '&' + str + ';'\r
            elif data[i - 1] != ';':\r
                self.syntax_error("bogus `&'")\r
                i = s + 1 # just past the &\r
                continue\r
\r
            # when we get here, str contains the translated text and i points\r
            # to the end of the string that is to be replaced\r
            data = data[:s] + str + data[i:]\r
            if rescan:\r
                i = s\r
            else:\r
                i = s + len(str)\r
\r
    # Interface - return a dictionary of all namespaces currently valid\r
    def getnamespace(self):\r
        nsdict = {}\r
        for t, d, nst in self.stack:\r
            nsdict.update(d)\r
        return nsdict\r
\r
    # Internal -- handle data as far as reasonable.  May leave state\r
    # and data to be processed by a subsequent call.  If 'end' is\r
    # true, force handling all data as if followed by EOF marker.\r
    def goahead(self, end):\r
        rawdata = self.rawdata\r
        i = 0\r
        n = len(rawdata)\r
        while i < n:\r
            if i > 0:\r
                self.__at_start = 0\r
            if self.nomoretags:\r
                data = rawdata[i:n]\r
                self.handle_data(data)\r
                self.lineno = self.lineno + data.count('\n')\r
                i = n\r
                break\r
            res = interesting.search(rawdata, i)\r
            if res:\r
                j = res.start(0)\r
            else:\r
                j = n\r
            if i < j:\r
                data = rawdata[i:j]\r
                if self.__at_start and space.match(data) is None:\r
                    self.syntax_error('illegal data at start of file')\r
                self.__at_start = 0\r
                if not self.stack and space.match(data) is None:\r
                    self.syntax_error('data not in content')\r
                if not self.__accept_utf8 and illegal.search(data):\r
                    self.syntax_error('illegal character in content')\r
                self.handle_data(data)\r
                self.lineno = self.lineno + data.count('\n')\r
            i = j\r
            if i == n: break\r
            if rawdata[i] == '<':\r
                if starttagopen.match(rawdata, i):\r
                    if self.literal:\r
                        data = rawdata[i]\r
                        self.handle_data(data)\r
                        self.lineno = self.lineno + data.count('\n')\r
                        i = i+1\r
                        continue\r
                    k = self.parse_starttag(i)\r
                    if k < 0: break\r
                    self.__seen_starttag = 1\r
                    self.lineno = self.lineno + rawdata[i:k].count('\n')\r
                    i = k\r
                    continue\r
                if endtagopen.match(rawdata, i):\r
                    k = self.parse_endtag(i)\r
                    if k < 0: break\r
                    self.lineno = self.lineno + rawdata[i:k].count('\n')\r
                    i =  k\r
                    continue\r
                if commentopen.match(rawdata, i):\r
                    if self.literal:\r
                        data = rawdata[i]\r
                        self.handle_data(data)\r
                        self.lineno = self.lineno + data.count('\n')\r
                        i = i+1\r
                        continue\r
                    k = self.parse_comment(i)\r
                    if k < 0: break\r
                    self.lineno = self.lineno + rawdata[i:k].count('\n')\r
                    i = k\r
                    continue\r
                if cdataopen.match(rawdata, i):\r
                    k = self.parse_cdata(i)\r
                    if k < 0: break\r
                    self.lineno = self.lineno + rawdata[i:k].count('\n')\r
                    i = k\r
                    continue\r
                res = xmldecl.match(rawdata, i)\r
                if res:\r
                    if not self.__at_start:\r
                        self.syntax_error("<?xml?> declaration not at start of document")\r
                    version, encoding, standalone = res.group('version',\r
                                                              'encoding',\r
                                                              'standalone')\r
                    if version[1:-1] != '1.0':\r
                        raise Error('only XML version 1.0 supported')\r
                    if encoding: encoding = encoding[1:-1]\r
                    if standalone: standalone = standalone[1:-1]\r
                    self.handle_xml(encoding, standalone)\r
                    i = res.end(0)\r
                    continue\r
                res = procopen.match(rawdata, i)\r
                if res:\r
                    k = self.parse_proc(i)\r
                    if k < 0: break\r
                    self.lineno = self.lineno + rawdata[i:k].count('\n')\r
                    i = k\r
                    continue\r
                res = doctype.match(rawdata, i)\r
                if res:\r
                    if self.literal:\r
                        data = rawdata[i]\r
                        self.handle_data(data)\r
                        self.lineno = self.lineno + data.count('\n')\r
                        i = i+1\r
                        continue\r
                    if self.__seen_doctype:\r
                        self.syntax_error('multiple DOCTYPE elements')\r
                    if self.__seen_starttag:\r
                        self.syntax_error('DOCTYPE not at beginning of document')\r
                    k = self.parse_doctype(res)\r
                    if k < 0: break\r
                    self.__seen_doctype = res.group('name')\r
                    if self.__map_case:\r
                        self.__seen_doctype = self.__seen_doctype.lower()\r
                    self.lineno = self.lineno + rawdata[i:k].count('\n')\r
                    i = k\r
                    continue\r
            elif rawdata[i] == '&':\r
                if self.literal:\r
                    data = rawdata[i]\r
                    self.handle_data(data)\r
                    i = i+1\r
                    continue\r
                res = charref.match(rawdata, i)\r
                if res is not None:\r
                    i = res.end(0)\r
                    if rawdata[i-1] != ';':\r
                        self.syntax_error("`;' missing in charref")\r
                        i = i-1\r
                    if not self.stack:\r
                        self.syntax_error('data not in content')\r
                    self.handle_charref(res.group('char')[:-1])\r
                    self.lineno = self.lineno + res.group(0).count('\n')\r
                    continue\r
                res = entityref.match(rawdata, i)\r
                if res is not None:\r
                    i = res.end(0)\r
                    if rawdata[i-1] != ';':\r
                        self.syntax_error("`;' missing in entityref")\r
                        i = i-1\r
                    name = res.group('name')\r
                    if self.__map_case:\r
                        name = name.lower()\r
                    if name in self.entitydefs:\r
                        self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]\r
                        n = len(rawdata)\r
                        i = res.start(0)\r
                    else:\r
                        self.unknown_entityref(name)\r
                    self.lineno = self.lineno + res.group(0).count('\n')\r
                    continue\r
            elif rawdata[i] == ']':\r
                if self.literal:\r
                    data = rawdata[i]\r
                    self.handle_data(data)\r
                    i = i+1\r
                    continue\r
                if n-i < 3:\r
                    break\r
                if cdataclose.match(rawdata, i):\r
                    self.syntax_error("bogus `]]>'")\r
                self.handle_data(rawdata[i])\r
                i = i+1\r
                continue\r
            else:\r
                raise Error('neither < nor & ??')\r
            # We get here only if incomplete matches but\r
            # nothing else\r
            break\r
        # end while\r
        if i > 0:\r
            self.__at_start = 0\r
        if end and i < n:\r
            data = rawdata[i]\r
            self.syntax_error("bogus `%s'" % data)\r
            if not self.__accept_utf8 and illegal.search(data):\r
                self.syntax_error('illegal character in content')\r
            self.handle_data(data)\r
            self.lineno = self.lineno + data.count('\n')\r
            self.rawdata = rawdata[i+1:]\r
            return self.goahead(end)\r
        self.rawdata = rawdata[i:]\r
        if end:\r
            if not self.__seen_starttag:\r
                self.syntax_error('no elements in file')\r
            if self.stack:\r
                self.syntax_error('missing end tags')\r
                while self.stack:\r
                    self.finish_endtag(self.stack[-1][0])\r
\r
    # Internal -- parse comment, return length or -1 if not terminated\r
    def parse_comment(self, i):\r
        rawdata = self.rawdata\r
        if rawdata[i:i+4] != '<!--':\r
            raise Error('unexpected call to handle_comment')\r
        res = commentclose.search(rawdata, i+4)\r
        if res is None:\r
            return -1\r
        if doubledash.search(rawdata, i+4, res.start(0)):\r
            self.syntax_error("`--' inside comment")\r
        if rawdata[res.start(0)-1] == '-':\r
            self.syntax_error('comment cannot end in three dashes')\r
        if not self.__accept_utf8 and \\r
           illegal.search(rawdata, i+4, res.start(0)):\r
            self.syntax_error('illegal character in comment')\r
        self.handle_comment(rawdata[i+4: res.start(0)])\r
        return res.end(0)\r
\r
    # Internal -- handle DOCTYPE tag, return length or -1 if not terminated\r
    def parse_doctype(self, res):\r
        rawdata = self.rawdata\r
        n = len(rawdata)\r
        name = res.group('name')\r
        if self.__map_case:\r
            name = name.lower()\r
        pubid, syslit = res.group('pubid', 'syslit')\r
        if pubid is not None:\r
            pubid = pubid[1:-1]         # remove quotes\r
            pubid = ' '.join(pubid.split()) # normalize\r
        if syslit is not None: syslit = syslit[1:-1] # remove quotes\r
        j = k = res.end(0)\r
        if k >= n:\r
            return -1\r
        if rawdata[k] == '[':\r
            level = 0\r
            k = k+1\r
            dq = sq = 0\r
            while k < n:\r
                c = rawdata[k]\r
                if not sq and c == '"':\r
                    dq = not dq\r
                elif not dq and c == "'":\r
                    sq = not sq\r
                elif sq or dq:\r
                    pass\r
                elif level <= 0 and c == ']':\r
                    res = endbracket.match(rawdata, k+1)\r
                    if res is None:\r
                        return -1\r
                    self.handle_doctype(name, pubid, syslit, rawdata[j+1:k])\r
                    return res.end(0)\r
                elif c == '<':\r
                    level = level + 1\r
                elif c == '>':\r
                    level = level - 1\r
                    if level < 0:\r
                        self.syntax_error("bogus `>' in DOCTYPE")\r
                k = k+1\r
        res = endbracketfind.match(rawdata, k)\r
        if res is None:\r
            return -1\r
        if endbracket.match(rawdata, k) is None:\r
            self.syntax_error('garbage in DOCTYPE')\r
        self.handle_doctype(name, pubid, syslit, None)\r
        return res.end(0)\r
\r
    # Internal -- handle CDATA tag, return length or -1 if not terminated\r
    def parse_cdata(self, i):\r
        rawdata = self.rawdata\r
        if rawdata[i:i+9] != '<![CDATA[':\r
            raise Error('unexpected call to parse_cdata')\r
        res = cdataclose.search(rawdata, i+9)\r
        if res is None:\r
            return -1\r
        if not self.__accept_utf8 and \\r
           illegal.search(rawdata, i+9, res.start(0)):\r
            self.syntax_error('illegal character in CDATA')\r
        if not self.stack:\r
            self.syntax_error('CDATA not in content')\r
        self.handle_cdata(rawdata[i+9:res.start(0)])\r
        return res.end(0)\r
\r
    __xml_namespace_attributes = {'ns':None, 'src':None, 'prefix':None}\r
    # Internal -- handle a processing instruction tag\r
    def parse_proc(self, i):\r
        rawdata = self.rawdata\r
        end = procclose.search(rawdata, i)\r
        if end is None:\r
            return -1\r
        j = end.start(0)\r
        if not self.__accept_utf8 and illegal.search(rawdata, i+2, j):\r
            self.syntax_error('illegal character in processing instruction')\r
        res = tagfind.match(rawdata, i+2)\r
        if res is None:\r
            raise Error('unexpected call to parse_proc')\r
        k = res.end(0)\r
        name = res.group(0)\r
        if self.__map_case:\r
            name = name.lower()\r
        if name == 'xml:namespace':\r
            self.syntax_error('old-fashioned namespace declaration')\r
            self.__use_namespaces = -1\r
            # namespace declaration\r
            # this must come after the <?xml?> declaration (if any)\r
            # and before the <!DOCTYPE> (if any).\r
            if self.__seen_doctype or self.__seen_starttag:\r
                self.syntax_error('xml:namespace declaration too late in document')\r
            attrdict, namespace, k = self.parse_attributes(name, k, j)\r
            if namespace:\r
                self.syntax_error('namespace declaration inside namespace declaration')\r
            for attrname in attrdict.keys():\r
                if not attrname in self.__xml_namespace_attributes:\r
                    self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)\r
            if not 'ns' in attrdict or not 'prefix' in attrdict:\r
                self.syntax_error('xml:namespace without required attributes')\r
            prefix = attrdict.get('prefix')\r
            if ncname.match(prefix) is None:\r
                self.syntax_error('xml:namespace illegal prefix value')\r
                return end.end(0)\r
            if prefix in self.__namespaces:\r
                self.syntax_error('xml:namespace prefix not unique')\r
            self.__namespaces[prefix] = attrdict['ns']\r
        else:\r
            if name.lower() == 'xml':\r
                self.syntax_error('illegal processing instruction target name')\r
            self.handle_proc(name, rawdata[k:j])\r
        return end.end(0)\r
\r
    # Internal -- parse attributes between i and j\r
    def parse_attributes(self, tag, i, j):\r
        rawdata = self.rawdata\r
        attrdict = {}\r
        namespace = {}\r
        while i < j:\r
            res = attrfind.match(rawdata, i)\r
            if res is None:\r
                break\r
            attrname, attrvalue = res.group('name', 'value')\r
            if self.__map_case:\r
                attrname = attrname.lower()\r
            i = res.end(0)\r
            if attrvalue is None:\r
                self.syntax_error("no value specified for attribute `%s'" % attrname)\r
                attrvalue = attrname\r
            elif attrvalue[:1] == "'" == attrvalue[-1:] or \\r
                 attrvalue[:1] == '"' == attrvalue[-1:]:\r
                attrvalue = attrvalue[1:-1]\r
            elif not self.__accept_unquoted_attributes:\r
                self.syntax_error("attribute `%s' value not quoted" % attrname)\r
            res = xmlns.match(attrname)\r
            if res is not None:\r
                # namespace declaration\r
                ncname = res.group('ncname')\r
                namespace[ncname or ''] = attrvalue or None\r
                if not self.__use_namespaces:\r
                    self.__use_namespaces = len(self.stack)+1\r
                continue\r
            if '<' in attrvalue:\r
                self.syntax_error("`<' illegal in attribute value")\r
            if attrname in attrdict:\r
                self.syntax_error("attribute `%s' specified twice" % attrname)\r
            attrvalue = attrvalue.translate(attrtrans)\r
            attrdict[attrname] = self.translate_references(attrvalue)\r
        return attrdict, namespace, i\r
\r
    # Internal -- handle starttag, return length or -1 if not terminated\r
    def parse_starttag(self, i):\r
        rawdata = self.rawdata\r
        # i points to start of tag\r
        end = endbracketfind.match(rawdata, i+1)\r
        if end is None:\r
            return -1\r
        tag = starttagmatch.match(rawdata, i)\r
        if tag is None or tag.end(0) != end.end(0):\r
            self.syntax_error('garbage in starttag')\r
            return end.end(0)\r
        nstag = tagname = tag.group('tagname')\r
        if self.__map_case:\r
            nstag = tagname = nstag.lower()\r
        if not self.__seen_starttag and self.__seen_doctype and \\r
           tagname != self.__seen_doctype:\r
            self.syntax_error('starttag does not match DOCTYPE')\r
        if self.__seen_starttag and not self.stack:\r
            self.syntax_error('multiple elements on top level')\r
        k, j = tag.span('attrs')\r
        attrdict, nsdict, k = self.parse_attributes(tagname, k, j)\r
        self.stack.append((tagname, nsdict, nstag))\r
        if self.__use_namespaces:\r
            res = qname.match(tagname)\r
        else:\r
            res = None\r
        if res is not None:\r
            prefix, nstag = res.group('prefix', 'local')\r
            if prefix is None:\r
                prefix = ''\r
            ns = None\r
            for t, d, nst in self.stack:\r
                if prefix in d:\r
                    ns = d[prefix]\r
            if ns is None and prefix != '':\r
                ns = self.__namespaces.get(prefix)\r
            if ns is not None:\r
                nstag = ns + ' ' + nstag\r
            elif prefix != '':\r
                nstag = prefix + ':' + nstag # undo split\r
            self.stack[-1] = tagname, nsdict, nstag\r
        # translate namespace of attributes\r
        attrnamemap = {} # map from new name to old name (used for error reporting)\r
        for key in attrdict.keys():\r
            attrnamemap[key] = key\r
        if self.__use_namespaces:\r
            nattrdict = {}\r
            for key, val in attrdict.items():\r
                okey = key\r
                res = qname.match(key)\r
                if res is not None:\r
                    aprefix, key = res.group('prefix', 'local')\r
                    if self.__map_case:\r
                        key = key.lower()\r
                    if aprefix is not None:\r
                        ans = None\r
                        for t, d, nst in self.stack:\r
                            if aprefix in d:\r
                                ans = d[aprefix]\r
                        if ans is None:\r
                            ans = self.__namespaces.get(aprefix)\r
                        if ans is not None:\r
                            key = ans + ' ' + key\r
                        else:\r
                            key = aprefix + ':' + key\r
                nattrdict[key] = val\r
                attrnamemap[key] = okey\r
            attrdict = nattrdict\r
        attributes = self.attributes.get(nstag)\r
        if attributes is not None:\r
            for key in attrdict.keys():\r
                if not key in attributes:\r
                    self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))\r
            for key, val in attributes.items():\r
                if val is not None and not key in attrdict:\r
                    attrdict[key] = val\r
        method = self.elements.get(nstag, (None, None))[0]\r
        self.finish_starttag(nstag, attrdict, method)\r
        if tag.group('slash') == '/':\r
            self.finish_endtag(tagname)\r
        return tag.end(0)\r
\r
    # Internal -- parse endtag\r
    def parse_endtag(self, i):\r
        rawdata = self.rawdata\r
        end = endbracketfind.match(rawdata, i+1)\r
        if end is None:\r
            return -1\r
        res = tagfind.match(rawdata, i+2)\r
        if res is None:\r
            if self.literal:\r
                self.handle_data(rawdata[i])\r
                return i+1\r
            if not self.__accept_missing_endtag_name:\r
                self.syntax_error('no name specified in end tag')\r
            tag = self.stack[-1][0]\r
            k = i+2\r
        else:\r
            tag = res.group(0)\r
            if self.__map_case:\r
                tag = tag.lower()\r
            if self.literal:\r
                if not self.stack or tag != self.stack[-1][0]:\r
                    self.handle_data(rawdata[i])\r
                    return i+1\r
            k = res.end(0)\r
        if endbracket.match(rawdata, k) is None:\r
            self.syntax_error('garbage in end tag')\r
        self.finish_endtag(tag)\r
        return end.end(0)\r
\r
    # Internal -- finish processing of start tag\r
    def finish_starttag(self, tagname, attrdict, method):\r
        if method is not None:\r
            self.handle_starttag(tagname, method, attrdict)\r
        else:\r
            self.unknown_starttag(tagname, attrdict)\r
\r
    # Internal -- finish processing of end tag\r
    def finish_endtag(self, tag):\r
        self.literal = 0\r
        if not tag:\r
            self.syntax_error('name-less end tag')\r
            found = len(self.stack) - 1\r
            if found < 0:\r
                self.unknown_endtag(tag)\r
                return\r
        else:\r
            found = -1\r
            for i in range(len(self.stack)):\r
                if tag == self.stack[i][0]:\r
                    found = i\r
            if found == -1:\r
                self.syntax_error('unopened end tag')\r
                return\r
        while len(self.stack) > found:\r
            if found < len(self.stack) - 1:\r
                self.syntax_error('missing close tag for %s' % self.stack[-1][2])\r
            nstag = self.stack[-1][2]\r
            method = self.elements.get(nstag, (None, None))[1]\r
            if method is not None:\r
                self.handle_endtag(nstag, method)\r
            else:\r
                self.unknown_endtag(nstag)\r
            if self.__use_namespaces == len(self.stack):\r
                self.__use_namespaces = 0\r
            del self.stack[-1]\r
\r
    # Overridable -- handle xml processing instruction\r
    def handle_xml(self, encoding, standalone):\r
        pass\r
\r
    # Overridable -- handle DOCTYPE\r
    def handle_doctype(self, tag, pubid, syslit, data):\r
        pass\r
\r
    # Overridable -- handle start tag\r
    def handle_starttag(self, tag, method, attrs):\r
        method(attrs)\r
\r
    # Overridable -- handle end tag\r
    def handle_endtag(self, tag, method):\r
        method()\r
\r
    # Example -- handle character reference, no need to override\r
    def handle_charref(self, name):\r
        try:\r
            if name[0] == 'x':\r
                n = int(name[1:], 16)\r
            else:\r
                n = int(name)\r
        except ValueError:\r
            self.unknown_charref(name)\r
            return\r
        if not 0 <= n <= 255:\r
            self.unknown_charref(name)\r
            return\r
        self.handle_data(chr(n))\r
\r
    # Definition of entities -- derived classes may override\r
    entitydefs = {'lt': '&#60;',        # must use charref\r
                  'gt': '&#62;',\r
                  'amp': '&#38;',       # must use charref\r
                  'quot': '&#34;',\r
                  'apos': '&#39;',\r
                  }\r
\r
    # Example -- handle data, should be overridden\r
    def handle_data(self, data):\r
        pass\r
\r
    # Example -- handle cdata, could be overridden\r
    def handle_cdata(self, data):\r
        pass\r
\r
    # Example -- handle comment, could be overridden\r
    def handle_comment(self, data):\r
        pass\r
\r
    # Example -- handle processing instructions, could be overridden\r
    def handle_proc(self, name, data):\r
        pass\r
\r
    # Example -- handle relatively harmless syntax errors, could be overridden\r
    def syntax_error(self, message):\r
        raise Error('Syntax error at line %d: %s' % (self.lineno, message))\r
\r
    # To be overridden -- handlers for unknown objects\r
    def unknown_starttag(self, tag, attrs): pass\r
    def unknown_endtag(self, tag): pass\r
    def unknown_charref(self, ref): pass\r
    def unknown_entityref(self, name):\r
        self.syntax_error("reference to unknown entity `&%s;'" % name)\r
\r
\r
class TestXMLParser(XMLParser):\r
\r
    def __init__(self, **kw):\r
        self.testdata = ""\r
        XMLParser.__init__(self, **kw)\r
\r
    def handle_xml(self, encoding, standalone):\r
        self.flush()\r
        print 'xml: encoding =',encoding,'standalone =',standalone\r
\r
    def handle_doctype(self, tag, pubid, syslit, data):\r
        self.flush()\r
        print 'DOCTYPE:',tag, repr(data)\r
\r
    def handle_data(self, data):\r
        self.testdata = self.testdata + data\r
        if len(repr(self.testdata)) >= 70:\r
            self.flush()\r
\r
    def flush(self):\r
        data = self.testdata\r
        if data:\r
            self.testdata = ""\r
            print 'data:', repr(data)\r
\r
    def handle_cdata(self, data):\r
        self.flush()\r
        print 'cdata:', repr(data)\r
\r
    def handle_proc(self, name, data):\r
        self.flush()\r
        print 'processing:',name,repr(data)\r
\r
    def handle_comment(self, data):\r
        self.flush()\r
        r = repr(data)\r
        if len(r) > 68:\r
            r = r[:32] + '...' + r[-32:]\r
        print 'comment:', r\r
\r
    def syntax_error(self, message):\r
        print 'error at line %d:' % self.lineno, message\r
\r
    def unknown_starttag(self, tag, attrs):\r
        self.flush()\r
        if not attrs:\r
            print 'start tag: <' + tag + '>'\r
        else:\r
            print 'start tag: <' + tag,\r
            for name, value in attrs.items():\r
                print name + '=' + '"' + value + '"',\r
            print '>'\r
\r
    def unknown_endtag(self, tag):\r
        self.flush()\r
        print 'end tag: </' + tag + '>'\r
\r
    def unknown_entityref(self, ref):\r
        self.flush()\r
        print '*** unknown entity ref: &' + ref + ';'\r
\r
    def unknown_charref(self, ref):\r
        self.flush()\r
        print '*** unknown char ref: &#' + ref + ';'\r
\r
    def close(self):\r
        XMLParser.close(self)\r
        self.flush()\r
\r
def test(args = None):\r
    import sys, getopt\r
    from time import time\r
\r
    if not args:\r
        args = sys.argv[1:]\r
\r
    opts, args = getopt.getopt(args, 'st')\r
    klass = TestXMLParser\r
    do_time = 0\r
    for o, a in opts:\r
        if o == '-s':\r
            klass = XMLParser\r
        elif o == '-t':\r
            do_time = 1\r
\r
    if args:\r
        file = args[0]\r
    else:\r
        file = 'test.xml'\r
\r
    if file == '-':\r
        f = sys.stdin\r
    else:\r
        try:\r
            f = open(file, 'r')\r
        except IOError, msg:\r
            print file, ":", msg\r
            sys.exit(1)\r
\r
    data = f.read()\r
    if f is not sys.stdin:\r
        f.close()\r
\r
    x = klass()\r
    t0 = time()\r
    try:\r
        if do_time:\r
            x.feed(data)\r
            x.close()\r
        else:\r
            for c in data:\r
                x.feed(c)\r
            x.close()\r
    except Error, msg:\r
        t1 = time()\r
        print msg\r
        if do_time:\r
            print 'total time: %g' % (t1-t0)\r
        sys.exit(1)\r
    t1 = time()\r
    if do_time:\r
        print 'total time: %g' % (t1-t0)\r
\r
\r
if __name__ == '__main__':\r
    test()\r