From 53855c6495b076143c7bf947817fc967e3068af2 Mon Sep 17 00:00:00 2001 From: Neal Norwitz Date: Tue, 17 Apr 2007 08:39:58 +0000 Subject: Remove the xmllib module that was obsolete. --- Doc/howto/regex.tex | 3 +- Doc/lib/lib.tex | 1 - Doc/lib/libxmllib.tex | 287 --------------- Lib/test/test_xmllib.py | 51 --- Lib/test/xmltests.py | 1 - Lib/xmllib.py | 929 ------------------------------------------------ 6 files changed, 1 insertion(+), 1271 deletions(-) delete mode 100644 Doc/lib/libxmllib.tex delete mode 100644 Lib/test/test_xmllib.py delete mode 100644 Lib/xmllib.py diff --git a/Doc/howto/regex.tex b/Doc/howto/regex.tex index 62b6daf..d911be6 100644 --- a/Doc/howto/regex.tex +++ b/Doc/howto/regex.tex @@ -522,8 +522,7 @@ then the module functions are probably more convenient. If a program contains a lot of regular expressions, or re-uses the same ones in several locations, then it might be worthwhile to collect all the definitions in one place, in a section of code that compiles all the -REs ahead of time. To take an example from the standard library, -here's an extract from \file{xmllib.py}: +REs ahead of time. To take an example from the standard library: \begin{verbatim} ref = re.compile( ... ) diff --git a/Doc/lib/lib.tex b/Doc/lib/lib.tex index 427d71d..b201039 100644 --- a/Doc/lib/lib.tex +++ b/Doc/lib/lib.tex @@ -171,7 +171,6 @@ and how to embed it in other applications. \input{xmlsaxutils} \input{xmlsaxreader} \input{libetree} -% \input{libxmllib} \input{fileformats} % Miscellaneous file formats \input{libcsv} diff --git a/Doc/lib/libxmllib.tex b/Doc/lib/libxmllib.tex deleted file mode 100644 index f7197ca..0000000 --- a/Doc/lib/libxmllib.tex +++ /dev/null @@ -1,287 +0,0 @@ -\section{\module{xmllib} --- - A parser for XML documents} - -\declaremodule{standard}{xmllib} -\modulesynopsis{A parser for XML documents.} -\moduleauthor{Sjoerd Mullender}{Sjoerd.Mullender@cwi.nl} -\sectionauthor{Sjoerd Mullender}{Sjoerd.Mullender@cwi.nl} - - -\index{XML} -\index{Extensible Markup Language} - -\deprecated{2.0}{Use \refmodule{xml.sax} instead. The newer XML - package includes full support for XML 1.0.} - -\versionchanged[Added namespace support]{1.5.2} - -This module defines a class \class{XMLParser} which serves as the basis -for parsing text files formatted in XML (Extensible Markup Language). - -\begin{classdesc}{XMLParser}{} -The \class{XMLParser} class must be instantiated without -arguments.\footnote{Actually, a number of keyword arguments are -recognized which influence the parser to accept certain non-standard -constructs. The following keyword arguments are currently -recognized. The defaults for all of these is \code{0} (false) except -for the last one for which the default is \code{1} (true). -\var{accept_unquoted_attributes} (accept certain attribute values -without requiring quotes), \var{accept_missing_endtag_name} (accept -end tags that look like \code{}), \var{map_case} (map upper case to -lower case in tags and attributes), \var{accept_utf8} (allow UTF-8 -characters in input; this is required according to the XML standard, -but Python does not as yet deal properly with these characters, so -this is not the default), \var{translate_attribute_references} (don't -attempt to translate character and entity references in attribute values).} -\end{classdesc} - -This class provides the following interface methods and instance variables: - -\begin{memberdesc}{attributes} -A mapping of element names to mappings. The latter mapping maps -attribute names that are valid for the element to the default value of -the attribute, or if there is no default to \code{None}. The default -value is the empty dictionary. This variable is meant to be -overridden, not extended since the default is shared by all instances -of \class{XMLParser}. -\end{memberdesc} - -\begin{memberdesc}{elements} -A mapping of element names to tuples. The tuples contain a function -for handling the start and end tag respectively of the element, or -\code{None} if the method \method{unknown_starttag()} or -\method{unknown_endtag()} is to be called. The default value is the -empty dictionary. This variable is meant to be overridden, not -extended since the default is shared by all instances of -\class{XMLParser}. -\end{memberdesc} - -\begin{memberdesc}{entitydefs} -A mapping of entitynames to their values. The default value contains -definitions for \code{'lt'}, \code{'gt'}, \code{'amp'}, \code{'quot'}, -and \code{'apos'}. -\end{memberdesc} - -\begin{methoddesc}{reset}{} -Reset the instance. Loses all unprocessed data. This is called -implicitly at the instantiation time. -\end{methoddesc} - -\begin{methoddesc}{setnomoretags}{} -Stop processing tags. Treat all following input as literal input -(CDATA). -\end{methoddesc} - -\begin{methoddesc}{setliteral}{} -Enter literal mode (CDATA mode). This mode is automatically exited -when the close tag matching the last unclosed open tag is encountered. -\end{methoddesc} - -\begin{methoddesc}{feed}{data} -Feed some text to the parser. It is processed insofar as it consists -of complete tags; incomplete data is buffered until more data is -fed or \method{close()} is called. -\end{methoddesc} - -\begin{methoddesc}{close}{} -Force processing of all buffered data as if it were followed by an -end-of-file mark. This method may be redefined by a derived class to -define additional processing at the end of the input, but the -redefined version should always call \method{close()}. -\end{methoddesc} - -\begin{methoddesc}{translate_references}{data} -Translate all entity and character references in \var{data} and -return the translated string. -\end{methoddesc} - -\begin{methoddesc}{getnamespace}{} -Return a mapping of namespace abbreviations to namespace URIs that are -currently in effect. -\end{methoddesc} - -\begin{methoddesc}{handle_xml}{encoding, standalone} -This method is called when the \samp{} tag is processed. -The arguments are the values of the encoding and standalone attributes -in the tag. Both encoding and standalone are optional. The values -passed to \method{handle_xml()} default to \code{None} and the string -\code{'no'} respectively. -\end{methoddesc} - -\begin{methoddesc}{handle_doctype}{tag, pubid, syslit, data} -This\index{DOCTYPE declaration} method is called when the -\samp{} declaration is processed. The arguments are the -tag name of the root element, the Formal Public\index{Formal Public -Identifier} Identifier (or \code{None} if not specified), the system -identifier, and the uninterpreted contents of the internal DTD subset -as a string (or \code{None} if not present). -\end{methoddesc} - -\begin{methoddesc}{handle_starttag}{tag, method, attributes} -This method is called to handle start tags for which a start tag -handler is defined in the instance variable \member{elements}. The -\var{tag} argument is the name of the tag, and the -\var{method} argument is the function (method) which should be used to -support semantic interpretation of the start tag. The -\var{attributes} argument is a dictionary of attributes, the key being -the \var{name} and the value being the \var{value} of the attribute -found inside the tag's \code{<>} brackets. Character and entity -references in the \var{value} have been interpreted. For instance, -for the start tag \code{}, this method -would be called as \code{handle_starttag('A', self.elements['A'][0], -\{'HREF': 'http://www.cwi.nl/'\})}. The base implementation simply -calls \var{method} with \var{attributes} as the only argument. -\end{methoddesc} - -\begin{methoddesc}{handle_endtag}{tag, method} -This method is called to handle endtags for which an end tag handler -is defined in the instance variable \member{elements}. The \var{tag} -argument is the name of the tag, and the \var{method} argument is the -function (method) which should be used to support semantic -interpretation of the end tag. For instance, for the endtag -\code{}, this method would be called as \code{handle_endtag('A', -self.elements['A'][1])}. The base implementation simply calls -\var{method}. -\end{methoddesc} - -\begin{methoddesc}{handle_data}{data} -This method is called to process arbitrary data. It is intended to be -overridden by a derived class; the base class implementation does -nothing. -\end{methoddesc} - -\begin{methoddesc}{handle_charref}{ref} -This method is called to process a character reference of the form -\samp{\&\#\var{ref};}. \var{ref} can either be a decimal number, -or a hexadecimal number when preceded by an \character{x}. -In the base implementation, \var{ref} must be a number in the -range 0-255. It translates the character to \ASCII{} and calls the -method \method{handle_data()} with the character as argument. If -\var{ref} is invalid or out of range, the method -\code{unknown_charref(\var{ref})} is called to handle the error. A -subclass must override this method to provide support for character -references outside of the \ASCII{} range. -\end{methoddesc} - -\begin{methoddesc}{handle_comment}{comment} -This method is called when a comment is encountered. The -\var{comment} argument is a string containing the text between the -\samp{} delimiters, but not the delimiters -themselves. For example, the comment \samp{} will -cause this method to be called with the argument \code{'text'}. The -default method does nothing. -\end{methoddesc} - -\begin{methoddesc}{handle_cdata}{data} -This method is called when a CDATA element is encountered. The -\var{data} argument is a string containing the text between the -\samp{} delimiters, but not the delimiters -themselves. For example, the entity \samp{} will -cause this method to be called with the argument \code{'text'}. The -default method does nothing, and is intended to be overridden. -\end{methoddesc} - -\begin{methoddesc}{handle_proc}{name, data} -This method is called when a processing instruction (PI) is -encountered. The \var{name} is the PI target, and the \var{data} -argument is a string containing the text between the PI target and the -closing delimiter, but not the delimiter itself. For example, the -instruction \samp{} will cause this method to be called -with the arguments \code{'XML'} and \code{'text'}. The default method -does nothing. Note that if a document starts with \samp{}, \method{handle_xml()} is called to handle it. -\end{methoddesc} - -\begin{methoddesc}{handle_special}{data} -This method is called when a declaration is encountered. The -\var{data} argument is a string containing the text between the -\samp{} delimiters, but not the delimiters -themselves. For example, the \index{ENTITY declaration}entity -declaration \samp{} will cause this method to be called -with the argument \code{'ENTITY text'}. The default method does -nothing. Note that \samp{} is handled separately if it -is located at the start of the document. -\end{methoddesc} - -\begin{methoddesc}{syntax_error}{message} -This method is called when a syntax error is encountered. The -\var{message} is a description of what was wrong. The default method -raises a \exception{RuntimeError} exception. If this method is -overridden, it is permissible for it to return. This method is only -called when the error can be recovered from. Unrecoverable errors -raise a \exception{RuntimeError} without first calling -\method{syntax_error()}. -\end{methoddesc} - -\begin{methoddesc}{unknown_starttag}{tag, attributes} -This method is called to process an unknown start tag. It is intended -to be overridden by a derived class; the base class implementation -does nothing. -\end{methoddesc} - -\begin{methoddesc}{unknown_endtag}{tag} -This method is called to process an unknown end tag. It is intended -to be overridden by a derived class; the base class implementation -does nothing. -\end{methoddesc} - -\begin{methoddesc}{unknown_charref}{ref} -This method is called to process unresolvable numeric character -references. It is intended to be overridden by a derived class; the -base class implementation does nothing. -\end{methoddesc} - -\begin{methoddesc}{unknown_entityref}{ref} -This method is called to process an unknown entity reference. It is -intended to be overridden by a derived class; the base class -implementation calls \method{syntax_error()} to signal an error. -\end{methoddesc} - - -\begin{seealso} - \seetitle[http://www.w3.org/TR/REC-xml]{Extensible Markup Language - (XML) 1.0}{The XML specification, published by the World - Wide Web Consortium (W3C), defines the syntax and - processor requirements for XML. References to additional - material on XML, including translations of the - specification, are available at - \url{http://www.w3.org/XML/}.} - - \seetitle[http://www.python.org/topics/xml/]{Python and XML - Processing}{The Python XML Topic Guide provides a great - deal of information on using XML from Python and links to - other sources of information on XML.} - - \seetitle[http://www.python.org/sigs/xml-sig/]{SIG for XML - Processing in Python}{The Python XML Special Interest - Group is developing substantial support for processing XML - from Python.} -\end{seealso} - - -\subsection{XML Namespaces \label{xml-namespace}} - -This module has support for XML namespaces as defined in the XML -Namespaces proposed recommendation. -\indexii{XML}{namespaces} - -Tag and attribute names that are defined in an XML namespace are -handled as if the name of the tag or element consisted of the -namespace (the URL that defines the namespace) followed by a -space and the name of the tag or attribute. For instance, the tag -\code{} is treated as if -the tag name was \code{'http://www.w3.org/TR/REC-html40 html'}, and -the tag \code{} inside the above -mentioned element is treated as if the tag name were -\code{'http://www.w3.org/TR/REC-html40 a'} and the attribute name as -if it were \code{'http://www.w3.org/TR/REC-html40 href'}. - -An older draft of the XML Namespaces proposal is also recognized, but -triggers a warning. - -\begin{seealso} - \seetitle[http://www.w3.org/TR/REC-xml-names/]{Namespaces in XML}{ - This World Wide Web Consortium recommendation describes the - proper syntax and processing requirements for namespaces in - XML.} -\end{seealso} diff --git a/Lib/test/test_xmllib.py b/Lib/test/test_xmllib.py deleted file mode 100644 index 0780bc9..0000000 --- a/Lib/test/test_xmllib.py +++ /dev/null @@ -1,51 +0,0 @@ -'''Test module to thest the xmllib module. - Sjoerd Mullender -''' - -testdoc = """\ - - - - -]> -Hello, world! -""" - -nsdoc = "" - -import warnings -warnings.filterwarnings("ignore", ".* xmllib .* obsolete.*", - DeprecationWarning, r'xmllib$') - -from test import test_support -import unittest -import xmllib - -class XMLParserTestCase(unittest.TestCase): - - def test_simple(self): - parser = xmllib.XMLParser() - for c in testdoc: - parser.feed(c) - parser.close() - - def test_default_namespace(self): - class H(xmllib.XMLParser): - def unknown_starttag(self, name, attr): - self.name, self.attr = name, attr - h=H() - h.feed(nsdoc) - h.close() - # The default namespace applies to elements... - self.assertEquals(h.name, "URI foo") - # but not to attributes - self.assertEquals(h.attr, {'attr':'val'}) - - -def test_main(): - test_support.run_unittest(XMLParserTestCase) - -if __name__ == "__main__": - test_main() diff --git a/Lib/test/xmltests.py b/Lib/test/xmltests.py index d203709..446fe30 100644 --- a/Lib/test/xmltests.py +++ b/Lib/test/xmltests.py @@ -17,5 +17,4 @@ runtest("test.test_pyexpat") runtest("test.test_sax") runtest("test.test_xml_etree") runtest("test.test_xml_etree_c") -runtest("test.test_xmllib") runtest("test.test_xmlrpc") diff --git a/Lib/xmllib.py b/Lib/xmllib.py deleted file mode 100644 index 6663a23..0000000 --- a/Lib/xmllib.py +++ /dev/null @@ -1,929 +0,0 @@ -"""A parser for XML, using the derived class as static DTD.""" - -# Author: Sjoerd Mullender. - -import re -import string - -import warnings -warnings.warn("The xmllib module is obsolete. Use xml.sax instead.", DeprecationWarning) -del warnings - -version = '0.3' - -class Error(RuntimeError): - pass - -# Regular expressions used for parsing - -_S = '[ \t\r\n]+' # white space -_opS = '[ \t\r\n]*' # optional white space -_Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*' # valid XML name -_QStr = "(?:'[^']*'|\"[^\"]*\")" # quoted XML string -illegal = re.compile('[^\t\r\n -\176\240-\377]') # illegal chars in content -interesting = re.compile('[]&<]') - -amp = re.compile('&') -ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]') -entityref = re.compile('&(?P' + _Name + ')[^-a-zA-Z0-9._:]') -charref = re.compile('&#(?P[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])') -space = re.compile(_S + '$') -newline = re.compile('\n') - -attrfind = re.compile( - _S + '(?P' + _Name + ')' - '(' + _opS + '=' + _opS + - '(?P'+_QStr+'|[-a-zA-Z0-9.:+*%?!\(\)_#=~]+))?') -starttagopen = re.compile('<' + _Name) -starttagend = re.compile(_opS + '(?P/?)>') -starttagmatch = re.compile('<(?P'+_Name+')' - '(?P(?:'+attrfind.pattern+')*)'+ - starttagend.pattern) -endtagopen = re.compile('') -endbracketfind = re.compile('(?:[^>\'"]|'+_QStr+')*>') -tagfind = re.compile(_Name) -cdataopen = re.compile(r'') -# this matches one of the following: -# SYSTEM SystemLiteral -# PUBLIC PubidLiteral SystemLiteral -_SystemLiteral = '(?P<%s>'+_QStr+')' -_PublicLiteral = '(?P<%s>"[-\'\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|' \ - "'[-\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*')" -_ExternalId = '(?:SYSTEM|' \ - 'PUBLIC'+_S+_PublicLiteral%'pubid'+ \ - ')'+_S+_SystemLiteral%'syslit' -doctype = re.compile(''+_Name+')' - '(?:'+_S+_ExternalId+')?'+_opS) -xmldecl = re.compile('<\?xml'+_S+ - 'version'+_opS+'='+_opS+'(?P'+_QStr+')'+ - '(?:'+_S+'encoding'+_opS+'='+_opS+ - "(?P'[A-Za-z][-A-Za-z0-9._]*'|" - '"[A-Za-z][-A-Za-z0-9._]*"))?' - '(?:'+_S+'standalone'+_opS+'='+_opS+ - '(?P\'(?:yes|no)\'|"(?:yes|no)"))?'+ - _opS+'\?>') -procopen = re.compile(r'<\?(?P' + _Name + ')' + _opS) -procclose = re.compile(_opS + r'\?>') -commentopen = re.compile('') -doubledash = re.compile('--') -attrtrans = string.maketrans(' \r\n\t', ' ') - -# definitions for XML namespaces -_NCName = '[a-zA-Z_][-a-zA-Z0-9._]*' # XML Name, minus the ":" -ncname = re.compile(_NCName + '$') -qname = re.compile('(?:(?P' + _NCName + '):)?' # optional prefix - '(?P' + _NCName + ')$') - -xmlns = re.compile('xmlns(?::(?P'+_NCName+'))?$') - -# XML parser base class -- find tags and call handler functions. -# Usage: p = XMLParser(); p.feed(data); ...; p.close(). -# The dtd is defined by deriving a class which defines methods with -# special names to handle tags: start_foo and end_foo to handle -# and , respectively. The data between tags is passed to the -# parser by calling self.handle_data() with some data as argument (the -# data may be split up in arbitrary chunks). - -class XMLParser: - attributes = {} # default, to be overridden - elements = {} # default, to be overridden - - # parsing options, settable using keyword args in __init__ - __accept_unquoted_attributes = 0 - __accept_missing_endtag_name = 0 - __map_case = 0 - __accept_utf8 = 0 - __translate_attribute_references = 1 - - # Interface -- initialize and reset this instance - def __init__(self, **kw): - self.__fixed = 0 - if 'accept_unquoted_attributes' in kw: - self.__accept_unquoted_attributes = kw['accept_unquoted_attributes'] - if 'accept_missing_endtag_name' in kw: - self.__accept_missing_endtag_name = kw['accept_missing_endtag_name'] - if 'map_case' in kw: - self.__map_case = kw['map_case'] - if 'accept_utf8' in kw: - self.__accept_utf8 = kw['accept_utf8'] - if 'translate_attribute_references' in kw: - self.__translate_attribute_references = kw['translate_attribute_references'] - self.reset() - - def __fixelements(self): - self.__fixed = 1 - self.elements = {} - self.__fixdict(self.__dict__) - self.__fixclass(self.__class__) - - def __fixclass(self, kl): - self.__fixdict(kl.__dict__) - for k in kl.__bases__: - self.__fixclass(k) - - def __fixdict(self, dict): - for key in dict.keys(): - if key[:6] == 'start_': - tag = key[6:] - start, end = self.elements.get(tag, (None, None)) - if start is None: - self.elements[tag] = getattr(self, key), end - elif key[:4] == 'end_': - tag = key[4:] - start, end = self.elements.get(tag, (None, None)) - if end is None: - self.elements[tag] = start, getattr(self, key) - - # Interface -- reset this instance. Loses all unprocessed data - def reset(self): - self.rawdata = '' - self.stack = [] - self.nomoretags = 0 - self.literal = 0 - self.lineno = 1 - self.__at_start = 1 - self.__seen_doctype = None - self.__seen_starttag = 0 - self.__use_namespaces = 0 - self.__namespaces = {'xml':None} # xml is implicitly declared - # backward compatibility hack: if elements not overridden, - # fill it in ourselves - if self.elements is XMLParser.elements: - self.__fixelements() - - # For derived classes only -- enter literal mode (CDATA) till EOF - def setnomoretags(self): - self.nomoretags = self.literal = 1 - - # For derived classes only -- enter literal mode (CDATA) - def setliteral(self, *args): - self.literal = 1 - - # Interface -- feed some data to the parser. Call this as - # often as you want, with as little or as much text as you - # want (may include '\n'). (This just saves the text, all the - # processing is done by goahead().) - def feed(self, data): - self.rawdata = self.rawdata + data - self.goahead(0) - - # Interface -- handle the remaining data - def close(self): - self.goahead(1) - if self.__fixed: - self.__fixed = 0 - # remove self.elements so that we don't leak - del self.elements - - # Interface -- translate references - def translate_references(self, data, all = 1): - if not self.__translate_attribute_references: - return data - i = 0 - while 1: - res = amp.search(data, i) - if res is None: - return data - s = res.start(0) - res = ref.match(data, s) - if res is None: - self.syntax_error("bogus `&'") - i = s+1 - continue - i = res.end(0) - str = res.group(1) - rescan = 0 - if str[0] == '#': - if str[1] == 'x': - str = chr(int(str[2:], 16)) - else: - str = chr(int(str[1:])) - if data[i - 1] != ';': - self.syntax_error("`;' missing after char reference") - i = i-1 - elif all: - if str in self.entitydefs: - str = self.entitydefs[str] - rescan = 1 - elif data[i - 1] != ';': - self.syntax_error("bogus `&'") - i = s + 1 # just past the & - continue - else: - self.syntax_error("reference to unknown entity `&%s;'" % str) - str = '&' + str + ';' - elif data[i - 1] != ';': - self.syntax_error("bogus `&'") - i = s + 1 # just past the & - continue - - # when we get here, str contains the translated text and i points - # to the end of the string that is to be replaced - data = data[:s] + str + data[i:] - if rescan: - i = s - else: - i = s + len(str) - - # Interface - return a dictionary of all namespaces currently valid - def getnamespace(self): - nsdict = {} - for t, d, nst in self.stack: - nsdict.update(d) - return nsdict - - # Internal -- handle data as far as reasonable. May leave state - # and data to be processed by a subsequent call. If 'end' is - # true, force handling all data as if followed by EOF marker. - def goahead(self, end): - rawdata = self.rawdata - i = 0 - n = len(rawdata) - while i < n: - if i > 0: - self.__at_start = 0 - if self.nomoretags: - data = rawdata[i:n] - self.handle_data(data) - self.lineno = self.lineno + data.count('\n') - i = n - break - res = interesting.search(rawdata, i) - if res: - j = res.start(0) - else: - j = n - if i < j: - data = rawdata[i:j] - if self.__at_start and space.match(data) is None: - self.syntax_error('illegal data at start of file') - self.__at_start = 0 - if not self.stack and space.match(data) is None: - self.syntax_error('data not in content') - if not self.__accept_utf8 and illegal.search(data): - self.syntax_error('illegal character in content') - self.handle_data(data) - self.lineno = self.lineno + data.count('\n') - i = j - if i == n: break - if rawdata[i] == '<': - if starttagopen.match(rawdata, i): - if self.literal: - data = rawdata[i] - self.handle_data(data) - self.lineno = self.lineno + data.count('\n') - i = i+1 - continue - k = self.parse_starttag(i) - if k < 0: break - self.__seen_starttag = 1 - self.lineno = self.lineno + rawdata[i:k].count('\n') - i = k - continue - if endtagopen.match(rawdata, i): - k = self.parse_endtag(i) - if k < 0: break - self.lineno = self.lineno + rawdata[i:k].count('\n') - i = k - continue - if commentopen.match(rawdata, i): - if self.literal: - data = rawdata[i] - self.handle_data(data) - self.lineno = self.lineno + data.count('\n') - i = i+1 - continue - k = self.parse_comment(i) - if k < 0: break - self.lineno = self.lineno + rawdata[i:k].count('\n') - i = k - continue - if cdataopen.match(rawdata, i): - k = self.parse_cdata(i) - if k < 0: break - self.lineno = self.lineno + rawdata[i:k].count('\n') - i = k - continue - res = xmldecl.match(rawdata, i) - if res: - if not self.__at_start: - self.syntax_error(" declaration not at start of document") - version, encoding, standalone = res.group('version', - 'encoding', - 'standalone') - if version[1:-1] != '1.0': - raise Error('only XML version 1.0 supported') - if encoding: encoding = encoding[1:-1] - if standalone: standalone = standalone[1:-1] - self.handle_xml(encoding, standalone) - i = res.end(0) - continue - res = procopen.match(rawdata, i) - if res: - k = self.parse_proc(i) - if k < 0: break - self.lineno = self.lineno + rawdata[i:k].count('\n') - i = k - continue - res = doctype.match(rawdata, i) - if res: - if self.literal: - data = rawdata[i] - self.handle_data(data) - self.lineno = self.lineno + data.count('\n') - i = i+1 - continue - if self.__seen_doctype: - self.syntax_error('multiple DOCTYPE elements') - if self.__seen_starttag: - self.syntax_error('DOCTYPE not at beginning of document') - k = self.parse_doctype(res) - if k < 0: break - self.__seen_doctype = res.group('name') - if self.__map_case: - self.__seen_doctype = self.__seen_doctype.lower() - self.lineno = self.lineno + rawdata[i:k].count('\n') - i = k - continue - elif rawdata[i] == '&': - if self.literal: - data = rawdata[i] - self.handle_data(data) - i = i+1 - continue - res = charref.match(rawdata, i) - if res is not None: - i = res.end(0) - if rawdata[i-1] != ';': - self.syntax_error("`;' missing in charref") - i = i-1 - if not self.stack: - self.syntax_error('data not in content') - self.handle_charref(res.group('char')[:-1]) - self.lineno = self.lineno + res.group(0).count('\n') - continue - res = entityref.match(rawdata, i) - if res is not None: - i = res.end(0) - if rawdata[i-1] != ';': - self.syntax_error("`;' missing in entityref") - i = i-1 - name = res.group('name') - if self.__map_case: - name = name.lower() - if name in self.entitydefs: - self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:] - n = len(rawdata) - i = res.start(0) - else: - self.unknown_entityref(name) - self.lineno = self.lineno + res.group(0).count('\n') - continue - elif rawdata[i] == ']': - if self.literal: - data = rawdata[i] - self.handle_data(data) - i = i+1 - continue - if n-i < 3: - break - if cdataclose.match(rawdata, i): - self.syntax_error("bogus `]]>'") - self.handle_data(rawdata[i]) - i = i+1 - continue - else: - raise Error('neither < nor & ??') - # We get here only if incomplete matches but - # nothing else - break - # end while - if i > 0: - self.__at_start = 0 - if end and i < n: - data = rawdata[i] - self.syntax_error("bogus `%s'" % data) - if not self.__accept_utf8 and illegal.search(data): - self.syntax_error('illegal character in content') - self.handle_data(data) - self.lineno = self.lineno + data.count('\n') - self.rawdata = rawdata[i+1:] - return self.goahead(end) - self.rawdata = rawdata[i:] - if end: - if not self.__seen_starttag: - self.syntax_error('no elements in file') - if self.stack: - self.syntax_error('missing end tags') - while self.stack: - self.finish_endtag(self.stack[-1][0]) - - # Internal -- parse comment, return length or -1 if not terminated - def parse_comment(self, i): - rawdata = self.rawdata - if rawdata[i:i+4] != '