+++ /dev/null
-"""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': '<', # must use charref\r
- 'gt': '>',\r
- 'amp': '&', # must use charref\r
- 'quot': '"',\r
- 'apos': ''',\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
projects / mirror_edk2.git / blobdiff