AppPkg/Applications/Python/Python-2.7.10/Lib/xmllib.py

   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.",
  10               DeprecationWarning, 2)
  11 del warnings
  12
  13 version = '0.3'
  14
  15 class Error(RuntimeError):
  16     pass
  17
  18 # Regular expressions used for parsing
  19
  20 _S = '[ \t\r\n]+'                       # white space
  21 _opS = '[ \t\r\n]*'                     # optional white space
  22 _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'    # valid XML name
  23 _QStr = "(?:'[^']*'|\"[^\"]*\")"        # quoted XML string
  24 illegal = re.compile('[^\t\r\n -\176\240-\377]') # illegal chars in content
  25 interesting = re.compile('[]&<]')
  26
  27 amp = re.compile('&')
  28 ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')
  29 entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')
  30 charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')
  31 space = re.compile(_S + '$')
  32 newline = re.compile('\n')
  33
  34 attrfind = re.compile(
  35     _S + '(?P<name>' + _Name + ')'
  36     '(' + _opS + '=' + _opS +
  37     '(?P<value>'+_QStr+'|[-a-zA-Z0-9.:+*%?!\(\)_#=~]+))?')
  38 starttagopen = re.compile('<' + _Name)
  39 starttagend = re.compile(_opS + '(?P<slash>/?)>')
  40 starttagmatch = re.compile('<(?P<tagname>'+_Name+')'
  41                       '(?P<attrs>(?:'+attrfind.pattern+')*)'+
  42                       starttagend.pattern)
  43 endtagopen = re.compile('</')
  44 endbracket = re.compile(_opS + '>')
  45 endbracketfind = re.compile('(?:[^>\'"]|'+_QStr+')*>')
  46 tagfind = re.compile(_Name)
  47 cdataopen = re.compile(r'<!\[CDATA\[')
  48 cdataclose = re.compile(r'\]\]>')
  49 # this matches one of the following:
  50 # SYSTEM SystemLiteral
  51 # PUBLIC PubidLiteral SystemLiteral
  52 _SystemLiteral = '(?P<%s>'+_QStr+')'
  53 _PublicLiteral = '(?P<%s>"[-\'\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|' \
  54                         "'[-\(\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*')"
  55 _ExternalId = '(?:SYSTEM|' \
  56                  'PUBLIC'+_S+_PublicLiteral%'pubid'+ \
  57               ')'+_S+_SystemLiteral%'syslit'
  58 doctype = re.compile('<!DOCTYPE'+_S+'(?P<name>'+_Name+')'
  59                      '(?:'+_S+_ExternalId+')?'+_opS)
  60 xmldecl = re.compile('<\?xml'+_S+
  61                      'version'+_opS+'='+_opS+'(?P<version>'+_QStr+')'+
  62                      '(?:'+_S+'encoding'+_opS+'='+_opS+
  63                         "(?P<encoding>'[A-Za-z][-A-Za-z0-9._]*'|"
  64                         '"[A-Za-z][-A-Za-z0-9._]*"))?'
  65                      '(?:'+_S+'standalone'+_opS+'='+_opS+
  66                         '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?'+
  67                      _opS+'\?>')
  68 procopen = re.compile(r'<\?(?P<proc>' + _Name + ')' + _opS)
  69 procclose = re.compile(_opS + r'\?>')
  70 commentopen = re.compile('<!--')
  71 commentclose = re.compile('-->')
  72 doubledash = re.compile('--')
  73 attrtrans = string.maketrans(' \r\n\t', '    ')
  74
  75 # definitions for XML namespaces
  76 _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'    # XML Name, minus the ":"
  77 ncname = re.compile(_NCName + '$')
  78 qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?' # optional prefix
  79                    '(?P<local>' + _NCName + ')$')
  80
  81 xmlns = re.compile('xmlns(?::(?P<ncname>'+_NCName+'))?$')
  82
  83 # XML parser base class -- find tags and call handler functions.
  84 # Usage: p = XMLParser(); p.feed(data); ...; p.close().
  85 # The dtd is defined by deriving a class which defines methods with
  86 # special names to handle tags: start_foo and end_foo to handle <foo>
  87 # and </foo>, respectively.  The data between tags is passed to the
  88 # parser by calling self.handle_data() with some data as argument (the
  89 # data may be split up in arbitrary chunks).
  90
  91 class XMLParser:
  92     attributes = {}                     # default, to be overridden
  93     elements = {}                       # default, to be overridden
  94
  95     # parsing options, settable using keyword args in __init__
  96     __accept_unquoted_attributes = 0
  97     __accept_missing_endtag_name = 0
  98     __map_case = 0
  99     __accept_utf8 = 0
 100     __translate_attribute_references = 1
 101
 102     # Interface -- initialize and reset this instance
 103     def __init__(self, **kw):
 104         self.__fixed = 0
 105         if 'accept_unquoted_attributes' in kw:
 106             self.__accept_unquoted_attributes = kw['accept_unquoted_attributes']
 107         if 'accept_missing_endtag_name' in kw:
 108             self.__accept_missing_endtag_name = kw['accept_missing_endtag_name']
 109         if 'map_case' in kw:
 110             self.__map_case = kw['map_case']
 111         if 'accept_utf8' in kw:
 112             self.__accept_utf8 = kw['accept_utf8']
 113         if 'translate_attribute_references' in kw:
 114             self.__translate_attribute_references = kw['translate_attribute_references']
 115         self.reset()
 116
 117     def __fixelements(self):
 118         self.__fixed = 1
 119         self.elements = {}
 120         self.__fixdict(self.__dict__)
 121         self.__fixclass(self.__class__)
 122
 123     def __fixclass(self, kl):
 124         self.__fixdict(kl.__dict__)
 125         for k in kl.__bases__:
 126             self.__fixclass(k)
 127
 128     def __fixdict(self, dict):
 129         for key in dict.keys():
 130             if key[:6] == 'start_':
 131                 tag = key[6:]
 132                 start, end = self.elements.get(tag, (None, None))
 133                 if start is None:
 134                     self.elements[tag] = getattr(self, key), end
 135             elif key[:4] == 'end_':
 136                 tag = key[4:]
 137                 start, end = self.elements.get(tag, (None, None))
 138                 if end is None:
 139                     self.elements[tag] = start, getattr(self, key)
 140
 141     # Interface -- reset this instance.  Loses all unprocessed data
 142     def reset(self):
 143         self.rawdata = ''
 144         self.stack = []
 145         self.nomoretags = 0
 146         self.literal = 0
 147         self.lineno = 1
 148         self.__at_start = 1
 149         self.__seen_doctype = None
 150         self.__seen_starttag = 0
 151         self.__use_namespaces = 0
 152         self.__namespaces = {'xml':None}   # xml is implicitly declared
 153         # backward compatibility hack: if elements not overridden,
 154         # fill it in ourselves
 155         if self.elements is XMLParser.elements:
 156             self.__fixelements()
 157
 158     # For derived classes only -- enter literal mode (CDATA) till EOF
 159     def setnomoretags(self):
 160         self.nomoretags = self.literal = 1
 161
 162     # For derived classes only -- enter literal mode (CDATA)
 163     def setliteral(self, *args):
 164         self.literal = 1
 165
 166     # Interface -- feed some data to the parser.  Call this as
 167     # often as you want, with as little or as much text as you
 168     # want (may include '\n').  (This just saves the text, all the
 169     # processing is done by goahead().)
 170     def feed(self, data):
 171         self.rawdata = self.rawdata + data
 172         self.goahead(0)
 173
 174     # Interface -- handle the remaining data
 175     def close(self):
 176         self.goahead(1)
 177         if self.__fixed:
 178             self.__fixed = 0
 179             # remove self.elements so that we don't leak
 180             del self.elements
 181
 182     # Interface -- translate references
 183     def translate_references(self, data, all = 1):
 184         if not self.__translate_attribute_references:
 185             return data
 186         i = 0
 187         while 1:
 188             res = amp.search(data, i)
 189             if res is None:
 190                 return data
 191             s = res.start(0)
 192             res = ref.match(data, s)
 193             if res is None:
 194                 self.syntax_error("bogus `&'")
 195                 i = s+1
 196                 continue
 197             i = res.end(0)
 198             str = res.group(1)
 199             rescan = 0
 200             if str[0] == '#':
 201                 if str[1] == 'x':
 202                     str = chr(int(str[2:], 16))
 203                 else:
 204                     str = chr(int(str[1:]))
 205                 if data[i - 1] != ';':
 206                     self.syntax_error("`;' missing after char reference")
 207                     i = i-1
 208             elif all:
 209                 if str in self.entitydefs:
 210                     str = self.entitydefs[str]
 211                     rescan = 1
 212                 elif data[i - 1] != ';':
 213                     self.syntax_error("bogus `&'")
 214                     i = s + 1 # just past the &
 215                     continue
 216                 else:
 217                     self.syntax_error("reference to unknown entity `&%s;'" % str)
 218                     str = '&' + str + ';'
 219             elif data[i - 1] != ';':
 220                 self.syntax_error("bogus `&'")
 221                 i = s + 1 # just past the &
 222                 continue
 223
 224             # when we get here, str contains the translated text and i points
 225             # to the end of the string that is to be replaced
 226             data = data[:s] + str + data[i:]
 227             if rescan:
 228                 i = s
 229             else:
 230                 i = s + len(str)
 231
 232     # Interface - return a dictionary of all namespaces currently valid
 233     def getnamespace(self):
 234         nsdict = {}
 235         for t, d, nst in self.stack:
 236             nsdict.update(d)
 237         return nsdict
 238
 239     # Internal -- handle data as far as reasonable.  May leave state
 240     # and data to be processed by a subsequent call.  If 'end' is
 241     # true, force handling all data as if followed by EOF marker.
 242     def goahead(self, end):
 243         rawdata = self.rawdata
 244         i = 0
 245         n = len(rawdata)
 246         while i < n:
 247             if i > 0:
 248                 self.__at_start = 0
 249             if self.nomoretags:
 250                 data = rawdata[i:n]
 251                 self.handle_data(data)
 252                 self.lineno = self.lineno + data.count('\n')
 253                 i = n
 254                 break
 255             res = interesting.search(rawdata, i)
 256             if res:
 257                 j = res.start(0)
 258             else:
 259                 j = n
 260             if i < j:
 261                 data = rawdata[i:j]
 262                 if self.__at_start and space.match(data) is None:
 263                     self.syntax_error('illegal data at start of file')
 264                 self.__at_start = 0
 265                 if not self.stack and space.match(data) is None:
 266                     self.syntax_error('data not in content')
 267                 if not self.__accept_utf8 and illegal.search(data):
 268                     self.syntax_error('illegal character in content')
 269                 self.handle_data(data)
 270                 self.lineno = self.lineno + data.count('\n')
 271             i = j
 272             if i == n: break
 273             if rawdata[i] == '<':
 274                 if starttagopen.match(rawdata, i):
 275                     if self.literal:
 276                         data = rawdata[i]
 277                         self.handle_data(data)
 278                         self.lineno = self.lineno + data.count('\n')
 279                         i = i+1
 280                         continue
 281                     k = self.parse_starttag(i)
 282                     if k < 0: break
 283                     self.__seen_starttag = 1
 284                     self.lineno = self.lineno + rawdata[i:k].count('\n')
 285                     i = k
 286                     continue
 287                 if endtagopen.match(rawdata, i):
 288                     k = self.parse_endtag(i)
 289                     if k < 0: break
 290                     self.lineno = self.lineno + rawdata[i:k].count('\n')
 291                     i =  k
 292                     continue
 293                 if commentopen.match(rawdata, i):
 294                     if self.literal:
 295                         data = rawdata[i]
 296                         self.handle_data(data)
 297                         self.lineno = self.lineno + data.count('\n')
 298                         i = i+1
 299                         continue
 300                     k = self.parse_comment(i)
 301                     if k < 0: break
 302                     self.lineno = self.lineno + rawdata[i:k].count('\n')
 303                     i = k
 304                     continue
 305                 if cdataopen.match(rawdata, i):
 306                     k = self.parse_cdata(i)
 307                     if k < 0: break
 308                     self.lineno = self.lineno + rawdata[i:k].count('\n')
 309                     i = k
 310                     continue
 311                 res = xmldecl.match(rawdata, i)
 312                 if res:
 313                     if not self.__at_start:
 314                         self.syntax_error("<?xml?> declaration not at start of document")
 315                     version, encoding, standalone = res.group('version',
 316                                                               'encoding',
 317                                                               'standalone')
 318                     if version[1:-1] != '1.0':
 319                         raise Error('only XML version 1.0 supported')
 320                     if encoding: encoding = encoding[1:-1]
 321                     if standalone: standalone = standalone[1:-1]
 322                     self.handle_xml(encoding, standalone)
 323                     i = res.end(0)
 324                     continue
 325                 res = procopen.match(rawdata, i)
 326                 if res:
 327                     k = self.parse_proc(i)
 328                     if k < 0: break
 329                     self.lineno = self.lineno + rawdata[i:k].count('\n')
 330                     i = k
 331                     continue
 332                 res = doctype.match(rawdata, i)
 333                 if res:
 334                     if self.literal:
 335                         data = rawdata[i]
 336                         self.handle_data(data)
 337                         self.lineno = self.lineno + data.count('\n')
 338                         i = i+1
 339                         continue
 340                     if self.__seen_doctype:
 341                         self.syntax_error('multiple DOCTYPE elements')
 342                     if self.__seen_starttag:
 343                         self.syntax_error('DOCTYPE not at beginning of document')
 344                     k = self.parse_doctype(res)
 345                     if k < 0: break
 346                     self.__seen_doctype = res.group('name')
 347                     if self.__map_case:
 348                         self.__seen_doctype = self.__seen_doctype.lower()
 349                     self.lineno = self.lineno + rawdata[i:k].count('\n')
 350                     i = k
 351                     continue
 352             elif rawdata[i] == '&':
 353                 if self.literal:
 354                     data = rawdata[i]
 355                     self.handle_data(data)
 356                     i = i+1
 357                     continue
 358                 res = charref.match(rawdata, i)
 359                 if res is not None:
 360                     i = res.end(0)
 361                     if rawdata[i-1] != ';':
 362                         self.syntax_error("`;' missing in charref")
 363                         i = i-1
 364                     if not self.stack:
 365                         self.syntax_error('data not in content')
 366                     self.handle_charref(res.group('char')[:-1])
 367                     self.lineno = self.lineno + res.group(0).count('\n')
 368                     continue
 369                 res = entityref.match(rawdata, i)
 370                 if res is not None:
 371                     i = res.end(0)
 372                     if rawdata[i-1] != ';':
 373                         self.syntax_error("`;' missing in entityref")
 374                         i = i-1
 375                     name = res.group('name')
 376                     if self.__map_case:
 377                         name = name.lower()
 378                     if name in self.entitydefs:
 379                         self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]
 380                         n = len(rawdata)
 381                         i = res.start(0)
 382                     else:
 383                         self.unknown_entityref(name)
 384                     self.lineno = self.lineno + res.group(0).count('\n')
 385                     continue
 386             elif rawdata[i] == ']':
 387                 if self.literal:
 388                     data = rawdata[i]
 389                     self.handle_data(data)
 390                     i = i+1
 391                     continue
 392                 if n-i < 3:
 393                     break
 394                 if cdataclose.match(rawdata, i):
 395                     self.syntax_error("bogus `]]>'")
 396                 self.handle_data(rawdata[i])
 397                 i = i+1
 398                 continue
 399             else:
 400                 raise Error('neither < nor & ??')
 401             # We get here only if incomplete matches but
 402             # nothing else
 403             break
 404         # end while
 405         if i > 0:
 406             self.__at_start = 0
 407         if end and i < n:
 408             data = rawdata[i]
 409             self.syntax_error("bogus `%s'" % data)
 410             if not self.__accept_utf8 and illegal.search(data):
 411                 self.syntax_error('illegal character in content')
 412             self.handle_data(data)
 413             self.lineno = self.lineno + data.count('\n')
 414             self.rawdata = rawdata[i+1:]
 415             return self.goahead(end)
 416         self.rawdata = rawdata[i:]
 417         if end:
 418             if not self.__seen_starttag:
 419                 self.syntax_error('no elements in file')
 420             if self.stack:
 421                 self.syntax_error('missing end tags')
 422                 while self.stack:
 423                     self.finish_endtag(self.stack[-1][0])
 424
 425     # Internal -- parse comment, return length or -1 if not terminated
 426     def parse_comment(self, i):
 427         rawdata = self.rawdata
 428         if rawdata[i:i+4] != '<!--':
 429             raise Error('unexpected call to handle_comment')
 430         res = commentclose.search(rawdata, i+4)
 431         if res is None:
 432             return -1
 433         if doubledash.search(rawdata, i+4, res.start(0)):
 434             self.syntax_error("`--' inside comment")
 435         if rawdata[res.start(0)-1] == '-':
 436             self.syntax_error('comment cannot end in three dashes')
 437         if not self.__accept_utf8 and \
 438            illegal.search(rawdata, i+4, res.start(0)):
 439             self.syntax_error('illegal character in comment')
 440         self.handle_comment(rawdata[i+4: res.start(0)])
 441         return res.end(0)
 442
 443     # Internal -- handle DOCTYPE tag, return length or -1 if not terminated
 444     def parse_doctype(self, res):
 445         rawdata = self.rawdata
 446         n = len(rawdata)
 447         name = res.group('name')
 448         if self.__map_case:
 449             name = name.lower()
 450         pubid, syslit = res.group('pubid', 'syslit')
 451         if pubid is not None:
 452             pubid = pubid[1:-1]         # remove quotes
 453             pubid = ' '.join(pubid.split()) # normalize
 454         if syslit is not None: syslit = syslit[1:-1] # remove quotes
 455         j = k = res.end(0)
 456         if k >= n:
 457             return -1
 458         if rawdata[k] == '[':
 459             level = 0
 460             k = k+1
 461             dq = sq = 0
 462             while k < n:
 463                 c = rawdata[k]
 464                 if not sq and c == '"':
 465                     dq = not dq
 466                 elif not dq and c == "'":
 467                     sq = not sq
 468                 elif sq or dq:
 469                     pass
 470                 elif level <= 0 and c == ']':
 471                     res = endbracket.match(rawdata, k+1)
 472                     if res is None:
 473                         return -1
 474                     self.handle_doctype(name, pubid, syslit, rawdata[j+1:k])
 475                     return res.end(0)
 476                 elif c == '<':
 477                     level = level + 1
 478                 elif c == '>':
 479                     level = level - 1
 480                     if level < 0:
 481                         self.syntax_error("bogus `>' in DOCTYPE")
 482                 k = k+1
 483         res = endbracketfind.match(rawdata, k)
 484         if res is None:
 485             return -1
 486         if endbracket.match(rawdata, k) is None:
 487             self.syntax_error('garbage in DOCTYPE')
 488         self.handle_doctype(name, pubid, syslit, None)
 489         return res.end(0)
 490
 491     # Internal -- handle CDATA tag, return length or -1 if not terminated
 492     def parse_cdata(self, i):
 493         rawdata = self.rawdata
 494         if rawdata[i:i+9] != '<![CDATA[':
 495             raise Error('unexpected call to parse_cdata')
 496         res = cdataclose.search(rawdata, i+9)
 497         if res is None:
 498             return -1
 499         if not self.__accept_utf8 and \
 500            illegal.search(rawdata, i+9, res.start(0)):
 501             self.syntax_error('illegal character in CDATA')
 502         if not self.stack:
 503             self.syntax_error('CDATA not in content')
 504         self.handle_cdata(rawdata[i+9:res.start(0)])
 505         return res.end(0)
 506
 507     __xml_namespace_attributes = {'ns':None, 'src':None, 'prefix':None}
 508     # Internal -- handle a processing instruction tag
 509     def parse_proc(self, i):
 510         rawdata = self.rawdata
 511         end = procclose.search(rawdata, i)
 512         if end is None:
 513             return -1
 514         j = end.start(0)
 515         if not self.__accept_utf8 and illegal.search(rawdata, i+2, j):
 516             self.syntax_error('illegal character in processing instruction')
 517         res = tagfind.match(rawdata, i+2)
 518         if res is None:
 519             raise Error('unexpected call to parse_proc')
 520         k = res.end(0)
 521         name = res.group(0)
 522         if self.__map_case:
 523             name = name.lower()
 524         if name == 'xml:namespace':
 525             self.syntax_error('old-fashioned namespace declaration')
 526             self.__use_namespaces = -1
 527             # namespace declaration
 528             # this must come after the <?xml?> declaration (if any)
 529             # and before the <!DOCTYPE> (if any).
 530             if self.__seen_doctype or self.__seen_starttag:
 531                 self.syntax_error('xml:namespace declaration too late in document')
 532             attrdict, namespace, k = self.parse_attributes(name, k, j)
 533             if namespace:
 534                 self.syntax_error('namespace declaration inside namespace declaration')
 535             for attrname in attrdict.keys():
 536                 if not attrname in self.__xml_namespace_attributes:
 537                     self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)
 538             if not 'ns' in attrdict or not 'prefix' in attrdict:
 539                 self.syntax_error('xml:namespace without required attributes')
 540             prefix = attrdict.get('prefix')
 541             if ncname.match(prefix) is None:
 542                 self.syntax_error('xml:namespace illegal prefix value')
 543                 return end.end(0)
 544             if prefix in self.__namespaces:
 545                 self.syntax_error('xml:namespace prefix not unique')
 546             self.__namespaces[prefix] = attrdict['ns']
 547         else:
 548             if name.lower() == 'xml':
 549                 self.syntax_error('illegal processing instruction target name')
 550             self.handle_proc(name, rawdata[k:j])
 551         return end.end(0)
 552
 553     # Internal -- parse attributes between i and j
 554     def parse_attributes(self, tag, i, j):
 555         rawdata = self.rawdata
 556         attrdict = {}
 557         namespace = {}
 558         while i < j:
 559             res = attrfind.match(rawdata, i)
 560             if res is None:
 561                 break
 562             attrname, attrvalue = res.group('name', 'value')
 563             if self.__map_case:
 564                 attrname = attrname.lower()
 565             i = res.end(0)
 566             if attrvalue is None:
 567                 self.syntax_error("no value specified for attribute `%s'" % attrname)
 568                 attrvalue = attrname
 569             elif attrvalue[:1] == "'" == attrvalue[-1:] or \
 570                  attrvalue[:1] == '"' == attrvalue[-1:]:
 571                 attrvalue = attrvalue[1:-1]
 572             elif not self.__accept_unquoted_attributes:
 573                 self.syntax_error("attribute `%s' value not quoted" % attrname)
 574             res = xmlns.match(attrname)
 575             if res is not None:
 576                 # namespace declaration
 577                 ncname = res.group('ncname')
 578                 namespace[ncname or ''] = attrvalue or None
 579                 if not self.__use_namespaces:
 580                     self.__use_namespaces = len(self.stack)+1
 581                 continue
 582             if '<' in attrvalue:
 583                 self.syntax_error("`<' illegal in attribute value")
 584             if attrname in attrdict:
 585                 self.syntax_error("attribute `%s' specified twice" % attrname)
 586             attrvalue = attrvalue.translate(attrtrans)
 587             attrdict[attrname] = self.translate_references(attrvalue)
 588         return attrdict, namespace, i
 589
 590     # Internal -- handle starttag, return length or -1 if not terminated
 591     def parse_starttag(self, i):
 592         rawdata = self.rawdata
 593         # i points to start of tag
 594         end = endbracketfind.match(rawdata, i+1)
 595         if end is None:
 596             return -1
 597         tag = starttagmatch.match(rawdata, i)
 598         if tag is None or tag.end(0) != end.end(0):
 599             self.syntax_error('garbage in starttag')
 600             return end.end(0)
 601         nstag = tagname = tag.group('tagname')
 602         if self.__map_case:
 603             nstag = tagname = nstag.lower()
 604         if not self.__seen_starttag and self.__seen_doctype and \
 605            tagname != self.__seen_doctype:
 606             self.syntax_error('starttag does not match DOCTYPE')
 607         if self.__seen_starttag and not self.stack:
 608             self.syntax_error('multiple elements on top level')
 609         k, j = tag.span('attrs')
 610         attrdict, nsdict, k = self.parse_attributes(tagname, k, j)
 611         self.stack.append((tagname, nsdict, nstag))
 612         if self.__use_namespaces:
 613             res = qname.match(tagname)
 614         else:
 615             res = None
 616         if res is not None:
 617             prefix, nstag = res.group('prefix', 'local')
 618             if prefix is None:
 619                 prefix = ''
 620             ns = None
 621             for t, d, nst in self.stack:
 622                 if prefix in d:
 623                     ns = d[prefix]
 624             if ns is None and prefix != '':
 625                 ns = self.__namespaces.get(prefix)
 626             if ns is not None:
 627                 nstag = ns + ' ' + nstag
 628             elif prefix != '':
 629                 nstag = prefix + ':' + nstag # undo split
 630             self.stack[-1] = tagname, nsdict, nstag
 631         # translate namespace of attributes
 632         attrnamemap = {} # map from new name to old name (used for error reporting)
 633         for key in attrdict.keys():
 634             attrnamemap[key] = key
 635         if self.__use_namespaces:
 636             nattrdict = {}
 637             for key, val in attrdict.items():
 638                 okey = key
 639                 res = qname.match(key)
 640                 if res is not None:
 641                     aprefix, key = res.group('prefix', 'local')
 642                     if self.__map_case:
 643                         key = key.lower()
 644                     if aprefix is not None:
 645                         ans = None
 646                         for t, d, nst in self.stack:
 647                             if aprefix in d:
 648                                 ans = d[aprefix]
 649                         if ans is None:
 650                             ans = self.__namespaces.get(aprefix)
 651                         if ans is not None:
 652                             key = ans + ' ' + key
 653                         else:
 654                             key = aprefix + ':' + key
 655                 nattrdict[key] = val
 656                 attrnamemap[key] = okey
 657             attrdict = nattrdict
 658         attributes = self.attributes.get(nstag)
 659         if attributes is not None:
 660             for key in attrdict.keys():
 661                 if not key in attributes:
 662                     self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))
 663             for key, val in attributes.items():
 664                 if val is not None and not key in attrdict:
 665                     attrdict[key] = val
 666         method = self.elements.get(nstag, (None, None))[0]
 667         self.finish_starttag(nstag, attrdict, method)
 668         if tag.group('slash') == '/':
 669             self.finish_endtag(tagname)
 670         return tag.end(0)
 671
 672     # Internal -- parse endtag
 673     def parse_endtag(self, i):
 674         rawdata = self.rawdata
 675         end = endbracketfind.match(rawdata, i+1)
 676         if end is None:
 677             return -1
 678         res = tagfind.match(rawdata, i+2)
 679         if res is None:
 680             if self.literal:
 681                 self.handle_data(rawdata[i])
 682                 return i+1
 683             if not self.__accept_missing_endtag_name:
 684                 self.syntax_error('no name specified in end tag')
 685             tag = self.stack[-1][0]
 686             k = i+2
 687         else:
 688             tag = res.group(0)
 689             if self.__map_case:
 690                 tag = tag.lower()
 691             if self.literal:
 692                 if not self.stack or tag != self.stack[-1][0]:
 693                     self.handle_data(rawdata[i])
 694                     return i+1
 695             k = res.end(0)
 696         if endbracket.match(rawdata, k) is None:
 697             self.syntax_error('garbage in end tag')
 698         self.finish_endtag(tag)
 699         return end.end(0)
 700
 701     # Internal -- finish processing of start tag
 702     def finish_starttag(self, tagname, attrdict, method):
 703         if method is not None:
 704             self.handle_starttag(tagname, method, attrdict)
 705         else:
 706             self.unknown_starttag(tagname, attrdict)
 707
 708     # Internal -- finish processing of end tag
 709     def finish_endtag(self, tag):
 710         self.literal = 0
 711         if not tag:
 712             self.syntax_error('name-less end tag')
 713             found = len(self.stack) - 1
 714             if found < 0:
 715                 self.unknown_endtag(tag)
 716                 return
 717         else:
 718             found = -1
 719             for i in range(len(self.stack)):
 720                 if tag == self.stack[i][0]:
 721                     found = i
 722             if found == -1:
 723                 self.syntax_error('unopened end tag')
 724                 return
 725         while len(self.stack) > found:
 726             if found < len(self.stack) - 1:
 727                 self.syntax_error('missing close tag for %s' % self.stack[-1][2])
 728             nstag = self.stack[-1][2]
 729             method = self.elements.get(nstag, (None, None))[1]
 730             if method is not None:
 731                 self.handle_endtag(nstag, method)
 732             else:
 733                 self.unknown_endtag(nstag)
 734             if self.__use_namespaces == len(self.stack):
 735                 self.__use_namespaces = 0
 736             del self.stack[-1]
 737
 738     # Overridable -- handle xml processing instruction
 739     def handle_xml(self, encoding, standalone):
 740         pass
 741
 742     # Overridable -- handle DOCTYPE
 743     def handle_doctype(self, tag, pubid, syslit, data):
 744         pass
 745
 746     # Overridable -- handle start tag
 747     def handle_starttag(self, tag, method, attrs):
 748         method(attrs)
 749
 750     # Overridable -- handle end tag
 751     def handle_endtag(self, tag, method):
 752         method()
 753
 754     # Example -- handle character reference, no need to override
 755     def handle_charref(self, name):
 756         try:
 757             if name[0] == 'x':
 758                 n = int(name[1:], 16)
 759             else:
 760                 n = int(name)
 761         except ValueError:
 762             self.unknown_charref(name)
 763             return
 764         if not 0 <= n <= 255:
 765             self.unknown_charref(name)
 766             return
 767         self.handle_data(chr(n))
 768
 769     # Definition of entities -- derived classes may override
 770     entitydefs = {'lt': '&#60;',        # must use charref
 771                   'gt': '&#62;',
 772                   'amp': '&#38;',       # must use charref
 773                   'quot': '&#34;',
 774                   'apos': '&#39;',
 775                   }
 776
 777     # Example -- handle data, should be overridden
 778     def handle_data(self, data):
 779         pass
 780
 781     # Example -- handle cdata, could be overridden
 782     def handle_cdata(self, data):
 783         pass
 784
 785     # Example -- handle comment, could be overridden
 786     def handle_comment(self, data):
 787         pass
 788
 789     # Example -- handle processing instructions, could be overridden
 790     def handle_proc(self, name, data):
 791         pass
 792
 793     # Example -- handle relatively harmless syntax errors, could be overridden
 794     def syntax_error(self, message):
 795         raise Error('Syntax error at line %d: %s' % (self.lineno, message))
 796
 797     # To be overridden -- handlers for unknown objects
 798     def unknown_starttag(self, tag, attrs): pass
 799     def unknown_endtag(self, tag): pass
 800     def unknown_charref(self, ref): pass
 801     def unknown_entityref(self, name):
 802         self.syntax_error("reference to unknown entity `&%s;'" % name)
 803
 804
 805 class TestXMLParser(XMLParser):
 806
 807     def __init__(self, **kw):
 808         self.testdata = ""
 809         XMLParser.__init__(self, **kw)
 810
 811     def handle_xml(self, encoding, standalone):
 812         self.flush()
 813         print 'xml: encoding =',encoding,'standalone =',standalone
 814
 815     def handle_doctype(self, tag, pubid, syslit, data):
 816         self.flush()
 817         print 'DOCTYPE:',tag, repr(data)
 818
 819     def handle_data(self, data):
 820         self.testdata = self.testdata + data
 821         if len(repr(self.testdata)) >= 70:
 822             self.flush()
 823
 824     def flush(self):
 825         data = self.testdata
 826         if data:
 827             self.testdata = ""
 828             print 'data:', repr(data)
 829
 830     def handle_cdata(self, data):
 831         self.flush()
 832         print 'cdata:', repr(data)
 833
 834     def handle_proc(self, name, data):
 835         self.flush()
 836         print 'processing:',name,repr(data)
 837
 838     def handle_comment(self, data):
 839         self.flush()
 840         r = repr(data)
 841         if len(r) > 68:
 842             r = r[:32] + '...' + r[-32:]
 843         print 'comment:', r
 844
 845     def syntax_error(self, message):
 846         print 'error at line %d:' % self.lineno, message
 847
 848     def unknown_starttag(self, tag, attrs):
 849         self.flush()
 850         if not attrs:
 851             print 'start tag: <' + tag + '>'
 852         else:
 853             print 'start tag: <' + tag,
 854             for name, value in attrs.items():
 855                 print name + '=' + '"' + value + '"',
 856             print '>'
 857
 858     def unknown_endtag(self, tag):
 859         self.flush()
 860         print 'end tag: </' + tag + '>'
 861
 862     def unknown_entityref(self, ref):
 863         self.flush()
 864         print '*** unknown entity ref: &' + ref + ';'
 865
 866     def unknown_charref(self, ref):
 867         self.flush()
 868         print '*** unknown char ref: &#' + ref + ';'
 869
 870     def close(self):
 871         XMLParser.close(self)
 872         self.flush()
 873
 874 def test(args = None):
 875     import sys, getopt
 876     from time import time
 877
 878     if not args:
 879         args = sys.argv[1:]
 880
 881     opts, args = getopt.getopt(args, 'st')
 882     klass = TestXMLParser
 883     do_time = 0
 884     for o, a in opts:
 885         if o == '-s':
 886             klass = XMLParser
 887         elif o == '-t':
 888             do_time = 1
 889
 890     if args:
 891         file = args[0]
 892     else:
 893         file = 'test.xml'
 894
 895     if file == '-':
 896         f = sys.stdin
 897     else:
 898         try:
 899             f = open(file, 'r')
 900         except IOError, msg:
 901             print file, ":", msg
 902             sys.exit(1)
 903
 904     data = f.read()
 905     if f is not sys.stdin:
 906         f.close()
 907
 908     x = klass()
 909     t0 = time()
 910     try:
 911         if do_time:
 912             x.feed(data)
 913             x.close()
 914         else:
 915             for c in data:
 916                 x.feed(c)
 917             x.close()
 918     except Error, msg:
 919         t1 = time()
 920         print msg
 921         if do_time:
 922             print 'total time: %g' % (t1-t0)
 923         sys.exit(1)
 924     t1 = time()
 925     if do_time:
 926         print 'total time: %g' % (t1-t0)
 927
 928
 929 if __name__ == '__main__':
 930     test()