1 """A parser for XML, using the derived class as static DTD."""

     2 

     3 # Author: Sjoerd Mullender.

     4 

     5 import re

     6 import string

     7 

     8 import warnings

     9 warnings.warn("The xmllib module is obsolete.  Use xml.sax instead.", DeprecationWarning)

    10 del warnings

    11 

    12 version = '0.3'

    13 

    14 class Error(RuntimeError):

    15     pass

    16 

    17 # Regular expressions used for parsing

    18 

    19 _S = '[ \t\r\n]+'                       # white space

    20 _opS = '[ \t\r\n]*'                     # optional white space

    21 _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'    # valid XML name

    22 _QStr = "(?:'[^']*'|\"[^\"]*\")"        # quoted XML string

    23 illegal = re.compile('[^\t\r\n -\176\240-\377]') # illegal chars in content

    24 interesting = re.compile('[]&<]')

    25 

    26 amp = re.compile('&')

    27 ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')

    28 entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')

    29 charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')

    30 space = re.compile(_S + '$')

    31 newline = re.compile('\n')

    32 

    33 attrfind = re.compile(

    34     _S + '(?P<name>' + _Name + ')'

    35     '(' + _opS + '=' + _opS +

    36     '(?P<value>'+_QStr+'|[-a-zA-Z0-9.:+*%?!\(\)_#=~]+))?')

    37 starttagopen = re.compile('<' + _Name)

    38 starttagend = re.compile(_opS + '(?P<slash>/?)>')

    39 starttagmatch = re.compile('<(?P<tagname>'+_Name+')'

    40                       '(?P<attrs>(?:'+attrfind.pattern+')*)'+

    41                       starttagend.pattern)

    42 endtagopen = re.compile('</')

    43 endbracket = re.compile(_opS + '>')

    44 endbracketfind = re.compile('(?:[^>\'"]|'+_QStr+')*>')

    45 tagfind = re.compile(_Name)

    46 cdataopen = re.compile(r'<!\[CDATA\[')

    47 cdataclose = re.compile(r'\]\]>')

    48 # this matches one of the following:

    49 # SYSTEM SystemLiteral

    50 # PUBLIC PubidLiteral SystemLiteral

    51 _SystemLiteral = '(?P<%s>'+_QStr+')'

    52 _PublicLiteral = '(?P<%s>"[-\'\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|' \

    53                         "'[-\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*')"

    54 _ExternalId = '(?:SYSTEM|' \

    55                  'PUBLIC'+_S+_PublicLiteral%'pubid'+ \

    56               ')'+_S+_SystemLiteral%'syslit'

    57 doctype = re.compile('<!DOCTYPE'+_S+'(?P<name>'+_Name+')'

    58                      '(?:'+_S+_ExternalId+')?'+_opS)

    59 xmldecl = re.compile('<\?xml'+_S+

    60                      'version'+_opS+'='+_opS+'(?P<version>'+_QStr+')'+

    61                      '(?:'+_S+'encoding'+_opS+'='+_opS+

    62                         "(?P<encoding>'[A-Za-z][-A-Za-z0-9._]*'|"

    63                         '"[A-Za-z][-A-Za-z0-9._]*"))?'

    64                      '(?:'+_S+'standalone'+_opS+'='+_opS+

    65                         '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?'+

    66                      _opS+'\?>')

    67 procopen = re.compile(r'<\?(?P<proc>' + _Name + ')' + _opS)

    68 procclose = re.compile(_opS + r'\?>')

    69 commentopen = re.compile('<!--')

    70 commentclose = re.compile('-->')

    71 doubledash = re.compile('--')

    72 attrtrans = string.maketrans(' \r\n\t', '    ')

    73 

    74 # definitions for XML namespaces

    75 _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'    # XML Name, minus the ":"

    76 ncname = re.compile(_NCName + '$')

    77 qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?' # optional prefix

    78                    '(?P<local>' + _NCName + ')$')

    79 

    80 xmlns = re.compile('xmlns(?::(?P<ncname>'+_NCName+'))?$')

    81 

    82 # XML parser base class -- find tags and call handler functions.

    83 # Usage: p = XMLParser(); p.feed(data); ...; p.close().

    84 # The dtd is defined by deriving a class which defines methods with

    85 # special names to handle tags: start_foo and end_foo to handle <foo>

    86 # and </foo>, respectively.  The data between tags is passed to the

    87 # parser by calling self.handle_data() with some data as argument (the

    88 # data may be split up in arbitrary chunks).

    89 

    90 class XMLParser:

    91     attributes = {}                     # default, to be overridden

    92     elements = {}                       # default, to be overridden

    93 

    94     # parsing options, settable using keyword args in __init__

    95     __accept_unquoted_attributes = 0

    96     __accept_missing_endtag_name = 0

    97     __map_case = 0

    98     __accept_utf8 = 0

    99     __translate_attribute_references = 1

   100 

   101     # Interface -- initialize and reset this instance

   102     def __init__(self, **kw):

   103         self.__fixed = 0

   104         if 'accept_unquoted_attributes' in kw:

   105             self.__accept_unquoted_attributes = kw['accept_unquoted_attributes']

   106         if 'accept_missing_endtag_name' in kw:

   107             self.__accept_missing_endtag_name = kw['accept_missing_endtag_name']

   108         if 'map_case' in kw:

   109             self.__map_case = kw['map_case']

   110         if 'accept_utf8' in kw:

   111             self.__accept_utf8 = kw['accept_utf8']

   112         if 'translate_attribute_references' in kw:

   113             self.__translate_attribute_references = kw['translate_attribute_references']

   114         self.reset()

   115 

   116     def __fixelements(self):

   117         self.__fixed = 1

   118         self.elements = {}

   119         self.__fixdict(self.__dict__)

   120         self.__fixclass(self.__class__)

   121 

   122     def __fixclass(self, kl):

   123         self.__fixdict(kl.__dict__)

   124         for k in kl.__bases__:

   125             self.__fixclass(k)

   126 

   127     def __fixdict(self, dict):

   128         for key in dict.keys():

   129             if key[:6] == 'start_':

   130                 tag = key[6:]

   131                 start, end = self.elements.get(tag, (None, None))

   132                 if start is None:

   133                     self.elements[tag] = getattr(self, key), end

   134             elif key[:4] == 'end_':

   135                 tag = key[4:]

   136                 start, end = self.elements.get(tag, (None, None))

   137                 if end is None:

   138                     self.elements[tag] = start, getattr(self, key)

   139 

   140     # Interface -- reset this instance.  Loses all unprocessed data

   141     def reset(self):

   142         self.rawdata = ''

   143         self.stack = []

   144         self.nomoretags = 0

   145         self.literal = 0

   146         self.lineno = 1

   147         self.__at_start = 1

   148         self.__seen_doctype = None

   149         self.__seen_starttag = 0

   150         self.__use_namespaces = 0

   151         self.__namespaces = {'xml':None}   # xml is implicitly declared

   152         # backward compatibility hack: if elements not overridden,

   153         # fill it in ourselves

   154         if self.elements is XMLParser.elements:

   155             self.__fixelements()

   156 

   157     # For derived classes only -- enter literal mode (CDATA) till EOF

   158     def setnomoretags(self):

   159         self.nomoretags = self.literal = 1

   160 

   161     # For derived classes only -- enter literal mode (CDATA)

   162     def setliteral(self, *args):

   163         self.literal = 1

   164 

   165     # Interface -- feed some data to the parser.  Call this as

   166     # often as you want, with as little or as much text as you

   167     # want (may include '\n').  (This just saves the text, all the

   168     # processing is done by goahead().)

   169     def feed(self, data):

   170         self.rawdata = self.rawdata + data

   171         self.goahead(0)

   172 

   173     # Interface -- handle the remaining data

   174     def close(self):

   175         self.goahead(1)

   176         if self.__fixed:

   177             self.__fixed = 0

   178             # remove self.elements so that we don't leak

   179             del self.elements

   180 

   181     # Interface -- translate references

   182     def translate_references(self, data, all = 1):

   183         if not self.__translate_attribute_references:

   184             return data

   185         i = 0

   186         while 1:

   187             res = amp.search(data, i)

   188             if res is None:

   189                 return data

   190             s = res.start(0)

   191             res = ref.match(data, s)

   192             if res is None:

   193                 self.syntax_error("bogus `&'")

   194                 i = s+1

   195                 continue

   196             i = res.end(0)

   197             str = res.group(1)

   198             rescan = 0

   199             if str[0] == '#':

   200                 if str[1] == 'x':

   201                     str = chr(int(str[2:], 16))

   202                 else:

   203                     str = chr(int(str[1:]))

   204                 if data[i - 1] != ';':

   205                     self.syntax_error("`;' missing after char reference")

   206                     i = i-1

   207             elif all:

   208                 if str in self.entitydefs:

   209                     str = self.entitydefs[str]

   210                     rescan = 1

   211                 elif data[i - 1] != ';':

   212                     self.syntax_error("bogus `&'")

   213                     i = s + 1 # just past the &

   214                     continue

   215                 else:

   216                     self.syntax_error("reference to unknown entity `&%s;'" % str)

   217                     str = '&' + str + ';'

   218             elif data[i - 1] != ';':

   219                 self.syntax_error("bogus `&'")

   220                 i = s + 1 # just past the &

   221                 continue

   222 

   223             # when we get here, str contains the translated text and i points

   224             # to the end of the string that is to be replaced

   225             data = data[:s] + str + data[i:]

   226             if rescan:

   227                 i = s

   228             else:

   229                 i = s + len(str)

   230 

   231     # Interface - return a dictionary of all namespaces currently valid

   232     def getnamespace(self):

   233         nsdict = {}

   234         for t, d, nst in self.stack:

   235             nsdict.update(d)

   236         return nsdict

   237 

   238     # Internal -- handle data as far as reasonable.  May leave state

   239     # and data to be processed by a subsequent call.  If 'end' is

   240     # true, force handling all data as if followed by EOF marker.

   241     def goahead(self, end):

   242         rawdata = self.rawdata

   243         i = 0

   244         n = len(rawdata)

   245         while i < n:

   246             if i > 0:

   247                 self.__at_start = 0

   248             if self.nomoretags:

   249                 data = rawdata[i:n]

   250                 self.handle_data(data)

   251                 self.lineno = self.lineno + data.count('\n')

   252                 i = n

   253                 break

   254             res = interesting.search(rawdata, i)

   255             if res:

   256                 j = res.start(0)

   257             else:

   258                 j = n

   259             if i < j:

   260                 data = rawdata[i:j]

   261                 if self.__at_start and space.match(data) is None:

   262                     self.syntax_error('illegal data at start of file')

   263                 self.__at_start = 0

   264                 if not self.stack and space.match(data) is None:

   265                     self.syntax_error('data not in content')

   266                 if not self.__accept_utf8 and illegal.search(data):

   267                     self.syntax_error('illegal character in content')

   268                 self.handle_data(data)

   269                 self.lineno = self.lineno + data.count('\n')

   270             i = j

   271             if i == n: break

   272             if rawdata[i] == '<':

   273                 if starttagopen.match(rawdata, i):

   274                     if self.literal:

   275                         data = rawdata[i]

   276                         self.handle_data(data)

   277                         self.lineno = self.lineno + data.count('\n')

   278                         i = i+1

   279                         continue

   280                     k = self.parse_starttag(i)

   281                     if k < 0: break

   282                     self.__seen_starttag = 1

   283                     self.lineno = self.lineno + rawdata[i:k].count('\n')

   284                     i = k

   285                     continue

   286                 if endtagopen.match(rawdata, i):

   287                     k = self.parse_endtag(i)

   288                     if k < 0: break

   289                     self.lineno = self.lineno + rawdata[i:k].count('\n')

   290                     i =  k

   291                     continue

   292                 if commentopen.match(rawdata, i):

   293                     if self.literal:

   294                         data = rawdata[i]

   295                         self.handle_data(data)

   296                         self.lineno = self.lineno + data.count('\n')

   297                         i = i+1

   298                         continue

   299                     k = self.parse_comment(i)

   300                     if k < 0: break

   301                     self.lineno = self.lineno + rawdata[i:k].count('\n')

   302                     i = k

   303                     continue

   304                 if cdataopen.match(rawdata, i):

   305                     k = self.parse_cdata(i)

   306                     if k < 0: break

   307                     self.lineno = self.lineno + rawdata[i:k].count('\n')

   308                     i = k

   309                     continue

   310                 res = xmldecl.match(rawdata, i)

   311                 if res:

   312                     if not self.__at_start:

   313                         self.syntax_error("<?xml?> declaration not at start of document")

   314                     version, encoding, standalone = res.group('version',

   315                                                               'encoding',

   316                                                               'standalone')

   317                     if version[1:-1] != '1.0':

   318                         raise Error('only XML version 1.0 supported')

   319                     if encoding: encoding = encoding[1:-1]

   320                     if standalone: standalone = standalone[1:-1]

   321                     self.handle_xml(encoding, standalone)

   322                     i = res.end(0)

   323                     continue

   324                 res = procopen.match(rawdata, i)

   325                 if res:

   326                     k = self.parse_proc(i)

   327                     if k < 0: break

   328                     self.lineno = self.lineno + rawdata[i:k].count('\n')

   329                     i = k

   330                     continue

   331                 res = doctype.match(rawdata, i)

   332                 if res:

   333                     if self.literal:

   334                         data = rawdata[i]

   335                         self.handle_data(data)

   336                         self.lineno = self.lineno + data.count('\n')

   337                         i = i+1

   338                         continue

   339                     if self.__seen_doctype:

   340                         self.syntax_error('multiple DOCTYPE elements')

   341                     if self.__seen_starttag:

   342                         self.syntax_error('DOCTYPE not at beginning of document')

   343                     k = self.parse_doctype(res)

   344                     if k < 0: break

   345                     self.__seen_doctype = res.group('name')

   346                     if self.__map_case:

   347                         self.__seen_doctype = self.__seen_doctype.lower()

   348                     self.lineno = self.lineno + rawdata[i:k].count('\n')

   349                     i = k

   350                     continue

   351             elif rawdata[i] == '&':

   352                 if self.literal:

   353                     data = rawdata[i]

   354                     self.handle_data(data)

   355                     i = i+1

   356                     continue

   357                 res = charref.match(rawdata, i)

   358                 if res is not None:

   359                     i = res.end(0)

   360                     if rawdata[i-1] != ';':

   361                         self.syntax_error("`;' missing in charref")

   362                         i = i-1

   363                     if not self.stack:

   364                         self.syntax_error('data not in content')

   365                     self.handle_charref(res.group('char')[:-1])

   366                     self.lineno = self.lineno + res.group(0).count('\n')

   367                     continue

   368                 res = entityref.match(rawdata, i)

   369                 if res is not None:

   370                     i = res.end(0)

   371                     if rawdata[i-1] != ';':

   372                         self.syntax_error("`;' missing in entityref")

   373                         i = i-1

   374                     name = res.group('name')

   375                     if self.__map_case:

   376                         name = name.lower()

   377                     if name in self.entitydefs:

   378                         self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]

   379                         n = len(rawdata)

   380                         i = res.start(0)

   381                     else:

   382                         self.unknown_entityref(name)

   383                     self.lineno = self.lineno + res.group(0).count('\n')

   384                     continue

   385             elif rawdata[i] == ']':

   386                 if self.literal:

   387                     data = rawdata[i]

   388                     self.handle_data(data)

   389                     i = i+1

   390                     continue

   391                 if n-i < 3:

   392                     break

   393                 if cdataclose.match(rawdata, i):

   394                     self.syntax_error("bogus `]]>'")

   395                 self.handle_data(rawdata[i])

   396                 i = i+1

   397                 continue

   398             else:

   399                 raise Error('neither < nor & ??')

   400             # We get here only if incomplete matches but

   401             # nothing else

   402             break

   403         # end while

   404         if i > 0:

   405             self.__at_start = 0

   406         if end and i < n:

   407             data = rawdata[i]

   408             self.syntax_error("bogus `%s'" % data)

   409             if not self.__accept_utf8 and illegal.search(data):

   410                 self.syntax_error('illegal character in content')

   411             self.handle_data(data)

   412             self.lineno = self.lineno + data.count('\n')

   413             self.rawdata = rawdata[i+1:]

   414             return self.goahead(end)

   415         self.rawdata = rawdata[i:]

   416         if end:

   417             if not self.__seen_starttag:

   418                 self.syntax_error('no elements in file')

   419             if self.stack:

   420                 self.syntax_error('missing end tags')

   421                 while self.stack:

   422                     self.finish_endtag(self.stack[-1][0])

   423 

   424     # Internal -- parse comment, return length or -1 if not terminated

   425     def parse_comment(self, i):

   426         rawdata = self.rawdata

   427         if rawdata[i:i+4] != '<!--':

   428             raise Error('unexpected call to handle_comment')

   429         res = commentclose.search(rawdata, i+4)

   430         if res is None:

   431             return -1

   432         if doubledash.search(rawdata, i+4, res.start(0)):

   433             self.syntax_error("`--' inside comment")

   434         if rawdata[res.start(0)-1] == '-':

   435             self.syntax_error('comment cannot end in three dashes')

   436         if not self.__accept_utf8 and \

   437            illegal.search(rawdata, i+4, res.start(0)):

   438             self.syntax_error('illegal character in comment')

   439         self.handle_comment(rawdata[i+4: res.start(0)])

   440         return res.end(0)

   441 

   442     # Internal -- handle DOCTYPE tag, return length or -1 if not terminated

   443     def parse_doctype(self, res):

   444         rawdata = self.rawdata

   445         n = len(rawdata)

   446         name = res.group('name')

   447         if self.__map_case:

   448             name = name.lower()

   449         pubid, syslit = res.group('pubid', 'syslit')

   450         if pubid is not None:

   451             pubid = pubid[1:-1]         # remove quotes

   452             pubid = ' '.join(pubid.split()) # normalize

   453         if syslit is not None: syslit = syslit[1:-1] # remove quotes

   454         j = k = res.end(0)

   455         if k >= n:

   456             return -1

   457         if rawdata[k] == '[':

   458             level = 0

   459             k = k+1

   460             dq = sq = 0

   461             while k < n:

   462                 c = rawdata[k]

   463                 if not sq and c == '"':

   464                     dq = not dq

   465                 elif not dq and c == "'":

   466                     sq = not sq

   467                 elif sq or dq:

   468                     pass

   469                 elif level <= 0 and c == ']':

   470                     res = endbracket.match(rawdata, k+1)

   471                     if res is None:

   472                         return -1

   473                     self.handle_doctype(name, pubid, syslit, rawdata[j+1:k])

   474                     return res.end(0)

   475                 elif c == '<':

   476                     level = level + 1

   477                 elif c == '>':

   478                     level = level - 1

   479                     if level < 0:

   480                         self.syntax_error("bogus `>' in DOCTYPE")

   481                 k = k+1

   482         res = endbracketfind.match(rawdata, k)

   483         if res is None:

   484             return -1

   485         if endbracket.match(rawdata, k) is None:

   486             self.syntax_error('garbage in DOCTYPE')

   487         self.handle_doctype(name, pubid, syslit, None)

   488         return res.end(0)

   489 

   490     # Internal -- handle CDATA tag, return length or -1 if not terminated

   491     def parse_cdata(self, i):

   492         rawdata = self.rawdata

   493         if rawdata[i:i+9] != '<![CDATA[':

   494             raise Error('unexpected call to parse_cdata')

   495         res = cdataclose.search(rawdata, i+9)

   496         if res is None:

   497             return -1

   498         if not self.__accept_utf8 and \

   499            illegal.search(rawdata, i+9, res.start(0)):

   500             self.syntax_error('illegal character in CDATA')

   501         if not self.stack:

   502             self.syntax_error('CDATA not in content')

   503         self.handle_cdata(rawdata[i+9:res.start(0)])

   504         return res.end(0)

   505 

   506     __xml_namespace_attributes = {'ns':None, 'src':None, 'prefix':None}

   507     # Internal -- handle a processing instruction tag

   508     def parse_proc(self, i):

   509         rawdata = self.rawdata

   510         end = procclose.search(rawdata, i)

   511         if end is None:

   512             return -1

   513         j = end.start(0)

   514         if not self.__accept_utf8 and illegal.search(rawdata, i+2, j):

   515             self.syntax_error('illegal character in processing instruction')

   516         res = tagfind.match(rawdata, i+2)

   517         if res is None:

   518             raise Error('unexpected call to parse_proc')

   519         k = res.end(0)

   520         name = res.group(0)

   521         if self.__map_case:

   522             name = name.lower()

   523         if name == 'xml:namespace':

   524             self.syntax_error('old-fashioned namespace declaration')

   525             self.__use_namespaces = -1

   526             # namespace declaration

   527             # this must come after the <?xml?> declaration (if any)

   528             # and before the <!DOCTYPE> (if any).

   529             if self.__seen_doctype or self.__seen_starttag:

   530                 self.syntax_error('xml:namespace declaration too late in document')

   531             attrdict, namespace, k = self.parse_attributes(name, k, j)

   532             if namespace:

   533                 self.syntax_error('namespace declaration inside namespace declaration')

   534             for attrname in attrdict.keys():

   535                 if not attrname in self.__xml_namespace_attributes:

   536                     self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)

   537             if not 'ns' in attrdict or not 'prefix' in attrdict:

   538                 self.syntax_error('xml:namespace without required attributes')

   539             prefix = attrdict.get('prefix')

   540             if ncname.match(prefix) is None:

   541                 self.syntax_error('xml:namespace illegal prefix value')

   542                 return end.end(0)

   543             if prefix in self.__namespaces:

   544                 self.syntax_error('xml:namespace prefix not unique')

   545             self.__namespaces[prefix] = attrdict['ns']

   546         else:

   547             if name.lower() == 'xml':

   548                 self.syntax_error('illegal processing instruction target name')

   549             self.handle_proc(name, rawdata[k:j])

   550         return end.end(0)

   551 

   552     # Internal -- parse attributes between i and j

   553     def parse_attributes(self, tag, i, j):

   554         rawdata = self.rawdata

   555         attrdict = {}

   556         namespace = {}

   557         while i < j:

   558             res = attrfind.match(rawdata, i)

   559             if res is None:

   560                 break

   561             attrname, attrvalue = res.group('name', 'value')

   562             if self.__map_case:

   563                 attrname = attrname.lower()

   564             i = res.end(0)

   565             if attrvalue is None:

   566                 self.syntax_error("no value specified for attribute `%s'" % attrname)

   567                 attrvalue = attrname

   568             elif attrvalue[:1] == "'" == attrvalue[-1:] or \

   569                  attrvalue[:1] == '"' == attrvalue[-1:]:

   570                 attrvalue = attrvalue[1:-1]

   571             elif not self.__accept_unquoted_attributes:

   572                 self.syntax_error("attribute `%s' value not quoted" % attrname)

   573             res = xmlns.match(attrname)

   574             if res is not None:

   575                 # namespace declaration

   576                 ncname = res.group('ncname')

   577                 namespace[ncname or ''] = attrvalue or None

   578                 if not self.__use_namespaces:

   579                     self.__use_namespaces = len(self.stack)+1

   580                 continue

   581             if '<' in attrvalue:

   582                 self.syntax_error("`<' illegal in attribute value")

   583             if attrname in attrdict:

   584                 self.syntax_error("attribute `%s' specified twice" % attrname)

   585             attrvalue = attrvalue.translate(attrtrans)

   586             attrdict[attrname] = self.translate_references(attrvalue)

   587         return attrdict, namespace, i

   588 

   589     # Internal -- handle starttag, return length or -1 if not terminated

   590     def parse_starttag(self, i):

   591         rawdata = self.rawdata

   592         # i points to start of tag

   593         end = endbracketfind.match(rawdata, i+1)

   594         if end is None:

   595             return -1

   596         tag = starttagmatch.match(rawdata, i)

   597         if tag is None or tag.end(0) != end.end(0):

   598             self.syntax_error('garbage in starttag')

   599             return end.end(0)

   600         nstag = tagname = tag.group('tagname')

   601         if self.__map_case:

   602             nstag = tagname = nstag.lower()

   603         if not self.__seen_starttag and self.__seen_doctype and \

   604            tagname != self.__seen_doctype:

   605             self.syntax_error('starttag does not match DOCTYPE')

   606         if self.__seen_starttag and not self.stack:

   607             self.syntax_error('multiple elements on top level')

   608         k, j = tag.span('attrs')

   609         attrdict, nsdict, k = self.parse_attributes(tagname, k, j)

   610         self.stack.append((tagname, nsdict, nstag))

   611         if self.__use_namespaces:

   612             res = qname.match(tagname)

   613         else:

   614             res = None

   615         if res is not None:

   616             prefix, nstag = res.group('prefix', 'local')

   617             if prefix is None:

   618                 prefix = ''

   619             ns = None

   620             for t, d, nst in self.stack:

   621                 if prefix in d:

   622                     ns = d[prefix]

   623             if ns is None and prefix != '':

   624                 ns = self.__namespaces.get(prefix)

   625             if ns is not None:

   626                 nstag = ns + ' ' + nstag

   627             elif prefix != '':

   628                 nstag = prefix + ':' + nstag # undo split

   629             self.stack[-1] = tagname, nsdict, nstag

   630         # translate namespace of attributes

   631         attrnamemap = {} # map from new name to old name (used for error reporting)

   632         for key in attrdict.keys():

   633             attrnamemap[key] = key

   634         if self.__use_namespaces:

   635             nattrdict = {}

   636             for key, val in attrdict.items():

   637                 okey = key

   638                 res = qname.match(key)

   639                 if res is not None:

   640                     aprefix, key = res.group('prefix', 'local')

   641                     if self.__map_case:

   642                         key = key.lower()

   643                     if aprefix is not None:

   644                         ans = None

   645                         for t, d, nst in self.stack:

   646                             if aprefix in d:

   647                                 ans = d[aprefix]

   648                         if ans is None:

   649                             ans = self.__namespaces.get(aprefix)

   650                         if ans is not None:

   651                             key = ans + ' ' + key

   652                         else:

   653                             key = aprefix + ':' + key

   654                 nattrdict[key] = val

   655                 attrnamemap[key] = okey

   656             attrdict = nattrdict

   657         attributes = self.attributes.get(nstag)

   658         if attributes is not None:

   659             for key in attrdict.keys():

   660                 if not key in attributes:

   661                     self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))

   662             for key, val in attributes.items():

   663                 if val is not None and not key in attrdict:

   664                     attrdict[key] = val

   665         method = self.elements.get(nstag, (None, None))[0]

   666         self.finish_starttag(nstag, attrdict, method)

   667         if tag.group('slash') == '/':

   668             self.finish_endtag(tagname)

   669         return tag.end(0)

   670 

   671     # Internal -- parse endtag

   672     def parse_endtag(self, i):

   673         rawdata = self.rawdata

   674         end = endbracketfind.match(rawdata, i+1)

   675         if end is None:

   676             return -1

   677         res = tagfind.match(rawdata, i+2)

   678         if res is None:

   679             if self.literal:

   680                 self.handle_data(rawdata[i])

   681                 return i+1

   682             if not self.__accept_missing_endtag_name:

   683                 self.syntax_error('no name specified in end tag')

   684             tag = self.stack[-1][0]

   685             k = i+2

   686         else:

   687             tag = res.group(0)

   688             if self.__map_case:

   689                 tag = tag.lower()

   690             if self.literal:

   691                 if not self.stack or tag != self.stack[-1][0]:

   692                     self.handle_data(rawdata[i])

   693                     return i+1

   694             k = res.end(0)

   695         if endbracket.match(rawdata, k) is None:

   696             self.syntax_error('garbage in end tag')

   697         self.finish_endtag(tag)

   698         return end.end(0)

   699 

   700     # Internal -- finish processing of start tag

   701     def finish_starttag(self, tagname, attrdict, method):

   702         if method is not None:

   703             self.handle_starttag(tagname, method, attrdict)

   704         else:

   705             self.unknown_starttag(tagname, attrdict)

   706 

   707     # Internal -- finish processing of end tag

   708     def finish_endtag(self, tag):

   709         self.literal = 0

   710         if not tag:

   711             self.syntax_error('name-less end tag')

   712             found = len(self.stack) - 1

   713             if found < 0:

   714                 self.unknown_endtag(tag)

   715                 return

   716         else:

   717             found = -1

   718             for i in range(len(self.stack)):

   719                 if tag == self.stack[i][0]:

   720                     found = i

   721             if found == -1:

   722                 self.syntax_error('unopened end tag')

   723                 return

   724         while len(self.stack) > found:

   725             if found < len(self.stack) - 1:

   726                 self.syntax_error('missing close tag for %s' % self.stack[-1][2])

   727             nstag = self.stack[-1][2]

   728             method = self.elements.get(nstag, (None, None))[1]

   729             if method is not None:

   730                 self.handle_endtag(nstag, method)

   731             else:

   732                 self.unknown_endtag(nstag)

   733             if self.__use_namespaces == len(self.stack):

   734                 self.__use_namespaces = 0

   735             del self.stack[-1]

   736 

   737     # Overridable -- handle xml processing instruction

   738     def handle_xml(self, encoding, standalone):

   739         pass

   740 

   741     # Overridable -- handle DOCTYPE

   742     def handle_doctype(self, tag, pubid, syslit, data):

   743         pass

   744 

   745     # Overridable -- handle start tag

   746     def handle_starttag(self, tag, method, attrs):

   747         method(attrs)

   748 

   749     # Overridable -- handle end tag

   750     def handle_endtag(self, tag, method):

   751         method()

   752 

   753     # Example -- handle character reference, no need to override

   754     def handle_charref(self, name):

   755         try:

   756             if name[0] == 'x':

   757                 n = int(name[1:], 16)

   758             else:

   759                 n = int(name)

   760         except ValueError:

   761             self.unknown_charref(name)

   762             return

   763         if not 0 <= n <= 255:

   764             self.unknown_charref(name)

   765             return

   766         self.handle_data(chr(n))

   767 

   768     # Definition of entities -- derived classes may override

   769     entitydefs = {'lt': '<',        # must use charref

   770                   'gt': '>',

   771                   'amp': '&',       # must use charref

   772                   'quot': '"',

   773                   'apos': ''',

   774                   }

   775 

   776     # Example -- handle data, should be overridden

   777     def handle_data(self, data):

   778         pass

   779 

   780     # Example -- handle cdata, could be overridden

   781     def handle_cdata(self, data):

   782         pass

   783 

   784     # Example -- handle comment, could be overridden

   785     def handle_comment(self, data):

   786         pass

   787 

   788     # Example -- handle processing instructions, could be overridden

   789     def handle_proc(self, name, data):

   790         pass

   791 

   792     # Example -- handle relatively harmless syntax errors, could be overridden

   793     def syntax_error(self, message):

   794         raise Error('Syntax error at line %d: %s' % (self.lineno, message))

   795 

   796     # To be overridden -- handlers for unknown objects

   797     def unknown_starttag(self, tag, attrs): pass

   798     def unknown_endtag(self, tag): pass

   799     def unknown_charref(self, ref): pass

   800     def unknown_entityref(self, name):

   801         self.syntax_error("reference to unknown entity `&%s;'" % name)

   802 

   803 

   804 class TestXMLParser(XMLParser):

   805 

   806     def __init__(self, **kw):

   807         self.testdata = ""

   808         XMLParser.__init__(self, **kw)

   809 

   810     def handle_xml(self, encoding, standalone):

   811         self.flush()

   812         print 'xml: encoding =',encoding,'standalone =',standalone

   813 

   814     def handle_doctype(self, tag, pubid, syslit, data):

   815         self.flush()

   816         print 'DOCTYPE:',tag, repr(data)

   817 

   818     def handle_data(self, data):

   819         self.testdata = self.testdata + data

   820         if len(repr(self.testdata)) >= 70:

   821             self.flush()

   822 

   823     def flush(self):

   824         data = self.testdata

   825         if data:

   826             self.testdata = ""

   827             print 'data:', repr(data)

   828 

   829     def handle_cdata(self, data):

   830         self.flush()

   831         print 'cdata:', repr(data)

   832 

   833     def handle_proc(self, name, data):

   834         self.flush()

   835         print 'processing:',name,repr(data)

   836 

   837     def handle_comment(self, data):

   838         self.flush()

   839         r = repr(data)

   840         if len(r) > 68:

   841             r = r[:32] + '...' + r[-32:]

   842         print 'comment:', r

   843 

   844     def syntax_error(self, message):

   845         print 'error at line %d:' % self.lineno, message

   846 

   847     def unknown_starttag(self, tag, attrs):

   848         self.flush()

   849         if not attrs:

   850             print 'start tag: <' + tag + '>'

   851         else:

   852             print 'start tag: <' + tag,

   853             for name, value in attrs.items():

   854                 print name + '=' + '"' + value + '"',

   855             print '>'

   856 

   857     def unknown_endtag(self, tag):

   858         self.flush()

   859         print 'end tag: </' + tag + '>'

   860 

   861     def unknown_entityref(self, ref):

   862         self.flush()

   863         print '*** unknown entity ref: &' + ref + ';'

   864 

   865     def unknown_charref(self, ref):

   866         self.flush()

   867         print '*** unknown char ref: &#' + ref + ';'

   868 

   869     def close(self):

   870         XMLParser.close(self)

   871         self.flush()

   872 

   873 def test(args = None):

   874     import sys, getopt

   875     from time import time

   876 

   877     if not args:

   878         args = sys.argv[1:]

   879 

   880     opts, args = getopt.getopt(args, 'st')

   881     klass = TestXMLParser

   882     do_time = 0

   883     for o, a in opts:

   884         if o == '-s':

   885             klass = XMLParser

   886         elif o == '-t':

   887             do_time = 1

   888 

   889     if args:

   890         file = args[0]

   891     else:

   892         file = 'test.xml'

   893 

   894     if file == '-':

   895         f = sys.stdin

   896     else:

   897         try:

   898             f = open(file, 'r')

   899         except IOError, msg:

   900             print file, ":", msg

   901             sys.exit(1)

   902 

   903     data = f.read()

   904     if f is not sys.stdin:

   905         f.close()

   906 

   907     x = klass()

   908     t0 = time()

   909     try:

   910         if do_time:

   911             x.feed(data)

   912             x.close()

   913         else:

   914             for c in data:

   915                 x.feed(c)

   916             x.close()

   917     except Error, msg:

   918         t1 = time()

   919         print msg

   920         if do_time:

   921             print 'total time: %g' % (t1-t0)

   922         sys.exit(1)

   923     t1 = time()

   924     if do_time:

   925         print 'total time: %g' % (t1-t0)

   926 

   927 

   928 if __name__ == '__main__':

   929     test()