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