home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / snippets / ElementTree.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  25.8 KB  |  908 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'Comment',
  6.     'dump',
  7.     'Element',
  8.     'ElementTree',
  9.     'fromstring',
  10.     'iselement',
  11.     'iterparse',
  12.     'parse',
  13.     'PI',
  14.     'ProcessingInstruction',
  15.     'QName',
  16.     'SubElement',
  17.     'tostring',
  18.     'TreeBuilder',
  19.     'VERSION',
  20.     'XML',
  21.     'XMLTreeBuilder']
  22. import string
  23. import sys
  24. import re
  25.  
  26. class _SimpleElementPath:
  27.     
  28.     def find(self, element, tag):
  29.         for elem in element:
  30.             if elem.tag == tag:
  31.                 return elem
  32.         
  33.  
  34.     
  35.     def findtext(self, element, tag, default = None):
  36.         for elem in element:
  37.             if elem.tag == tag:
  38.                 if not elem.text:
  39.                     pass
  40.                 return ''
  41.         
  42.         return default
  43.  
  44.     
  45.     def findall(self, element, tag):
  46.         if tag[:3] == './/':
  47.             return element.getiterator(tag[3:])
  48.         result = []
  49.         for elem in element:
  50.             if elem.tag == tag:
  51.                 result.append(elem)
  52.                 continue
  53.             tag[:3] == './/'
  54.         
  55.         return result
  56.  
  57.  
  58.  
  59. try:
  60.     import ElementPath
  61. except ImportError:
  62.     ElementPath = _SimpleElementPath()
  63.  
  64. VERSION = '1.2.6'
  65.  
  66. class _ElementInterface:
  67.     tag = None
  68.     attrib = None
  69.     text = None
  70.     tail = None
  71.     
  72.     def __init__(self, tag, attrib):
  73.         self.tag = tag
  74.         self.attrib = attrib
  75.         self._children = []
  76.  
  77.     
  78.     def __repr__(self):
  79.         return '<Element %s at %x>' % (self.tag, id(self))
  80.  
  81.     
  82.     def makeelement(self, tag, attrib):
  83.         return Element(tag, attrib)
  84.  
  85.     
  86.     def __len__(self):
  87.         return len(self._children)
  88.  
  89.     
  90.     def __getitem__(self, index):
  91.         return self._children[index]
  92.  
  93.     
  94.     def __setitem__(self, index, element):
  95.         if not iselement(element):
  96.             raise AssertionError
  97.         self._children[index] = element
  98.  
  99.     
  100.     def __delitem__(self, index):
  101.         del self._children[index]
  102.  
  103.     
  104.     def __getslice__(self, start, stop):
  105.         return self._children[start:stop]
  106.  
  107.     
  108.     def __setslice__(self, start, stop, elements):
  109.         for element in elements:
  110.             if not iselement(element):
  111.                 raise AssertionError
  112.         
  113.         self._children[start:stop] = list(elements)
  114.  
  115.     
  116.     def __delslice__(self, start, stop):
  117.         del self._children[start:stop]
  118.  
  119.     
  120.     def append(self, element):
  121.         if not iselement(element):
  122.             raise AssertionError
  123.         self._children.append(element)
  124.  
  125.     
  126.     def insert(self, index, element):
  127.         if not iselement(element):
  128.             raise AssertionError
  129.         self._children.insert(index, element)
  130.  
  131.     
  132.     def remove(self, element):
  133.         if not iselement(element):
  134.             raise AssertionError
  135.         self._children.remove(element)
  136.  
  137.     
  138.     def getchildren(self):
  139.         return self._children
  140.  
  141.     
  142.     def find(self, path):
  143.         return ElementPath.find(self, path)
  144.  
  145.     
  146.     def findtext(self, path, default = None):
  147.         return ElementPath.findtext(self, path, default)
  148.  
  149.     
  150.     def findall(self, path):
  151.         return ElementPath.findall(self, path)
  152.  
  153.     
  154.     def clear(self):
  155.         self.attrib.clear()
  156.         self._children = []
  157.         self.text = None
  158.         self.tail = None
  159.  
  160.     
  161.     def get(self, key, default = None):
  162.         return self.attrib.get(key, default)
  163.  
  164.     
  165.     def set(self, key, value):
  166.         self.attrib[key] = value
  167.  
  168.     
  169.     def keys(self):
  170.         return self.attrib.keys()
  171.  
  172.     
  173.     def items(self):
  174.         return self.attrib.items()
  175.  
  176.     
  177.     def getiterator(self, tag = None):
  178.         nodes = []
  179.         if tag == '*':
  180.             tag = None
  181.         
  182.         if tag is None or self.tag == tag:
  183.             nodes.append(self)
  184.         
  185.         for node in self._children:
  186.             nodes.extend(node.getiterator(tag))
  187.         
  188.         return nodes
  189.  
  190.  
  191. _Element = _ElementInterface
  192.  
  193. def Element(tag, attrib = { }, **extra):
  194.     attrib = attrib.copy()
  195.     attrib.update(extra)
  196.     return _ElementInterface(tag, attrib)
  197.  
  198.  
  199. def SubElement(parent, tag, attrib = { }, **extra):
  200.     attrib = attrib.copy()
  201.     attrib.update(extra)
  202.     element = parent.makeelement(tag, attrib)
  203.     parent.append(element)
  204.     return element
  205.  
  206.  
  207. def Comment(text = None):
  208.     element = Element(Comment)
  209.     element.text = text
  210.     return element
  211.  
  212.  
  213. def ProcessingInstruction(target, text = None):
  214.     element = Element(ProcessingInstruction)
  215.     element.text = target
  216.     if text:
  217.         element.text = element.text + ' ' + text
  218.     
  219.     return element
  220.  
  221. PI = ProcessingInstruction
  222.  
  223. class QName:
  224.     
  225.     def __init__(self, text_or_uri, tag = None):
  226.         if tag:
  227.             text_or_uri = '{%s}%s' % (text_or_uri, tag)
  228.         
  229.         self.text = text_or_uri
  230.  
  231.     
  232.     def __str__(self):
  233.         return self.text
  234.  
  235.     
  236.     def __hash__(self):
  237.         return hash(self.text)
  238.  
  239.     
  240.     def __cmp__(self, other):
  241.         if isinstance(other, QName):
  242.             return cmp(self.text, other.text)
  243.         return cmp(self.text, other)
  244.  
  245.  
  246.  
  247. class ElementTree:
  248.     
  249.     def __init__(self, element = None, file = None):
  250.         if not element is None and iselement(element):
  251.             raise AssertionError
  252.         self._root = element
  253.         if file:
  254.             self.parse(file)
  255.         
  256.  
  257.     
  258.     def getroot(self):
  259.         return self._root
  260.  
  261.     
  262.     def _setroot(self, element):
  263.         if not iselement(element):
  264.             raise AssertionError
  265.         self._root = element
  266.  
  267.     
  268.     def parse(self, source, parser = None):
  269.         if not hasattr(source, 'read'):
  270.             source = open(source, 'rb')
  271.         
  272.         if not parser:
  273.             parser = XMLTreeBuilder()
  274.         
  275.         while None:
  276.             data = source.read(32768)
  277.             if not data:
  278.                 break
  279.             
  280.             continue
  281.             self._root = parser.close()
  282.             return self._root
  283.  
  284.     
  285.     def getiterator(self, tag = None):
  286.         if not self._root is not None:
  287.             raise AssertionError
  288.         return self._root.getiterator(tag)
  289.  
  290.     
  291.     def find(self, path):
  292.         if not self._root is not None:
  293.             raise AssertionError
  294.         if path[:1] == '/':
  295.             path = '.' + path
  296.         
  297.         return self._root.find(path)
  298.  
  299.     
  300.     def findtext(self, path, default = None):
  301.         if not self._root is not None:
  302.             raise AssertionError
  303.         if path[:1] == '/':
  304.             path = '.' + path
  305.         
  306.         return self._root.findtext(path, default)
  307.  
  308.     
  309.     def findall(self, path):
  310.         if not self._root is not None:
  311.             raise AssertionError
  312.         if path[:1] == '/':
  313.             path = '.' + path
  314.         
  315.         return self._root.findall(path)
  316.  
  317.     
  318.     def write(self, file, encoding = 'us-ascii'):
  319.         if not self._root is not None:
  320.             raise AssertionError
  321.         if not hasattr(file, 'write'):
  322.             file = open(file, 'wb')
  323.         
  324.         if not encoding:
  325.             encoding = 'us-ascii'
  326.         elif encoding != 'utf-8' and encoding != 'us-ascii':
  327.             file.write("<?xml version='1.0' encoding='%s'?>\n" % encoding)
  328.         
  329.         self._write(file, self._root, encoding, { })
  330.  
  331.     
  332.     def _write(self, file, node, encoding, namespaces):
  333.         tag = node.tag
  334.         if tag is Comment:
  335.             file.write('<!-- %s -->' % _escape_cdata(node.text, encoding))
  336.         elif tag is ProcessingInstruction:
  337.             file.write('<?%s?>' % _escape_cdata(node.text, encoding))
  338.         else:
  339.             items = node.items()
  340.             xmlns_items = []
  341.             
  342.             try:
  343.                 if isinstance(tag, QName) or tag[:1] == '{':
  344.                     (tag, xmlns) = fixtag(tag, namespaces)
  345.                     if xmlns:
  346.                         xmlns_items.append(xmlns)
  347.                     
  348.             except TypeError:
  349.                 _raise_serialization_error(tag)
  350.  
  351.             file.write('<' + _encode(tag, encoding))
  352.             if items or xmlns_items:
  353.                 items.sort()
  354.                 for k, v in items:
  355.                     
  356.                     try:
  357.                         if isinstance(k, QName) or k[:1] == '{':
  358.                             (k, xmlns) = fixtag(k, namespaces)
  359.                             if xmlns:
  360.                                 xmlns_items.append(xmlns)
  361.                             
  362.                     except TypeError:
  363.                         _raise_serialization_error(k)
  364.  
  365.                     
  366.                     try:
  367.                         if isinstance(v, QName):
  368.                             (v, xmlns) = fixtag(v, namespaces)
  369.                             if xmlns:
  370.                                 xmlns_items.append(xmlns)
  371.                             
  372.                     except TypeError:
  373.                         _raise_serialization_error(v)
  374.  
  375.                     file.write(' %s="%s"' % (_encode(k, encoding), _escape_attrib(v, encoding)))
  376.                 
  377.                 for k, v in xmlns_items:
  378.                     file.write(' %s="%s"' % (_encode(k, encoding), _escape_attrib(v, encoding)))
  379.                 
  380.             
  381.             if node.text or len(node):
  382.                 file.write('>')
  383.                 if node.text:
  384.                     file.write(_escape_cdata(node.text, encoding))
  385.                 
  386.                 for n in node:
  387.                     self._write(file, n, encoding, namespaces)
  388.                 
  389.                 file.write('</' + _encode(tag, encoding) + '>')
  390.             else:
  391.                 file.write(' />')
  392.             for k, v in xmlns_items:
  393.                 del namespaces[v]
  394.             
  395.         if node.tail:
  396.             file.write(_escape_cdata(node.tail, encoding))
  397.         
  398.  
  399.  
  400.  
  401. def iselement(element):
  402.     if not isinstance(element, _ElementInterface):
  403.         pass
  404.     return hasattr(element, 'tag')
  405.  
  406.  
  407. def dump(elem):
  408.     if not isinstance(elem, ElementTree):
  409.         elem = ElementTree(elem)
  410.     
  411.     elem.write(sys.stdout)
  412.     tail = elem.getroot().tail
  413.     if not tail or tail[-1] != '\n':
  414.         sys.stdout.write('\n')
  415.     
  416.  
  417.  
  418. def _encode(s, encoding):
  419.     
  420.     try:
  421.         return s.encode(encoding)
  422.     except AttributeError:
  423.         return s
  424.  
  425.  
  426. if sys.version[:3] == '1.5':
  427.     _escape = re.compile('[&<>\\"\\x80-\\xff]+')
  428. else:
  429.     _escape = re.compile(eval('u"[&<>\\"\\u0080-\\uffff]+"'))
  430. _escape_map = {
  431.     '&': '&',
  432.     '<': '<',
  433.     '>': '>',
  434.     '"': '"' }
  435. _namespace_map = {
  436.     'http://www.w3.org/XML/1998/namespace': 'xml',
  437.     'http://www.w3.org/1999/xhtml': 'html',
  438.     'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf',
  439.     'http://schemas.xmlsoap.org/wsdl/': 'wsdl' }
  440.  
  441. def _raise_serialization_error(text):
  442.     raise TypeError('cannot serialize %r (type %s)' % (text, type(text).__name__))
  443.  
  444.  
  445. def _encode_entity(text, pattern = _escape):
  446.     
  447.     def escape_entities(m, map = _escape_map):
  448.         out = []
  449.         append = out.append
  450.         for char in m.group():
  451.             text = map.get(char)
  452.             if text is None:
  453.                 text = '&#%d;' % ord(char)
  454.             
  455.             append(text)
  456.         
  457.         return string.join(out, '')
  458.  
  459.     
  460.     try:
  461.         return _encode(pattern.sub(escape_entities, text), 'ascii')
  462.     except TypeError:
  463.         _raise_serialization_error(text)
  464.  
  465.  
  466.  
  467. def _escape_cdata(text, encoding = None, replace = string.replace):
  468.     
  469.     try:
  470.         if encoding:
  471.             
  472.             try:
  473.                 text = _encode(text, encoding)
  474.             except UnicodeError:
  475.                 return _encode_entity(text)
  476.             
  477.  
  478.         None<EXCEPTION MATCH>UnicodeError
  479.         text = replace(text, '&', '&')
  480.         text = replace(text, '<', '<')
  481.         text = replace(text, '>', '>')
  482.         return text
  483.     except (TypeError, AttributeError):
  484.         _raise_serialization_error(text)
  485.  
  486.  
  487.  
  488. def _escape_attrib(text, encoding = None, replace = string.replace):
  489.     
  490.     try:
  491.         if encoding:
  492.             
  493.             try:
  494.                 text = _encode(text, encoding)
  495.             except UnicodeError:
  496.                 return _encode_entity(text)
  497.             
  498.  
  499.         None<EXCEPTION MATCH>UnicodeError
  500.         text = replace(text, '&', '&')
  501.         text = replace(text, "'", ''')
  502.         text = replace(text, '"', '"')
  503.         text = replace(text, '<', '<')
  504.         text = replace(text, '>', '>')
  505.         return text
  506.     except (TypeError, AttributeError):
  507.         _raise_serialization_error(text)
  508.  
  509.  
  510.  
  511. def fixtag(tag, namespaces):
  512.     if isinstance(tag, QName):
  513.         tag = tag.text
  514.     
  515.     (namespace_uri, tag) = string.split(tag[1:], '}', 1)
  516.     prefix = namespaces.get(namespace_uri)
  517.     if prefix is None:
  518.         prefix = _namespace_map.get(namespace_uri)
  519.         if prefix is None:
  520.             prefix = 'ns%d' % len(namespaces)
  521.         
  522.         namespaces[namespace_uri] = prefix
  523.         if prefix == 'xml':
  524.             xmlns = None
  525.         else:
  526.             xmlns = ('xmlns:%s' % prefix, namespace_uri)
  527.     else:
  528.         xmlns = None
  529.     return ('%s:%s' % (prefix, tag), xmlns)
  530.  
  531.  
  532. def parse(source, parser = None):
  533.     tree = ElementTree()
  534.     tree.parse(source, parser)
  535.     return tree
  536.  
  537.  
  538. class iterparse:
  539.     
  540.     def __init__(self, source, events = None):
  541.         if not hasattr(source, 'read'):
  542.             source = open(source, 'rb')
  543.         
  544.         self._file = source
  545.         self._events = []
  546.         self._index = 0
  547.         self.root = None
  548.         self._root = None
  549.         self._parser = XMLTreeBuilder()
  550.         parser = self._parser._parser
  551.         append = self._events.append
  552.         if events is None:
  553.             events = [
  554.                 'end']
  555.         
  556.         for event in events:
  557.             if event == 'start':
  558.                 
  559.                 try:
  560.                     parser.ordered_attributes = 1
  561.                     parser.specified_attributes = 1
  562.                     
  563.                     def handler(tag, attrib_in, event = event, append = append, start = self._parser._start_list):
  564.                         append((event, start(tag, attrib_in)))
  565.  
  566.                     parser.StartElementHandler = handler
  567.                 except AttributeError:
  568.                     
  569.                     def handler(tag, attrib_in, event = event, append = append, start = self._parser._start):
  570.                         append((event, start(tag, attrib_in)))
  571.  
  572.                     parser.StartElementHandler = handler
  573.                 except:
  574.                     None<EXCEPTION MATCH>AttributeError
  575.                 
  576.  
  577.             None<EXCEPTION MATCH>AttributeError
  578.             if event == 'end':
  579.                 
  580.                 def handler(tag, event = event, append = append, end = self._parser._end):
  581.                     append((event, end(tag)))
  582.  
  583.                 parser.EndElementHandler = handler
  584.                 continue
  585.             if event == 'start-ns':
  586.                 
  587.                 def handler(prefix, uri, event = event, append = append):
  588.                     
  589.                     try:
  590.                         uri = _encode(uri, 'ascii')
  591.                     except UnicodeError:
  592.                         pass
  593.  
  594.                     if not prefix:
  595.                         pass
  596.                     append((event, ('', uri)))
  597.  
  598.                 parser.StartNamespaceDeclHandler = handler
  599.                 continue
  600.             if event == 'end-ns':
  601.                 
  602.                 def handler(prefix, event = event, append = append):
  603.                     append((event, None))
  604.  
  605.                 parser.EndNamespaceDeclHandler = handler
  606.                 continue
  607.         
  608.  
  609.     
  610.     def next(self):
  611.         while None:
  612.             
  613.             try:
  614.                 item = self._events[self._index]
  615.             except IndexError:
  616.                 if self._parser is None:
  617.                     self.root = self._root
  618.                     
  619.                     try:
  620.                         raise StopIteration
  621.                     except NameError:
  622.                         raise IndexError
  623.                     except:
  624.                         None<EXCEPTION MATCH>NameError
  625.                     
  626.  
  627.                 None<EXCEPTION MATCH>NameError
  628.                 del self._events[:]
  629.                 self._index = 0
  630.                 data = self._file.read(16384)
  631.                 if data:
  632.                     self._parser.feed(data)
  633.                 else:
  634.                     self._root = self._parser.close()
  635.                     self._parser = None
  636.                 data
  637.  
  638.             self._index = self._index + 1
  639.             return item
  640.             continue
  641.             return None
  642.  
  643.     
  644.     try:
  645.         iter
  646.         
  647.         def __iter__(self):
  648.             return self
  649.  
  650.     except NameError:
  651.         
  652.         def __getitem__(self, index):
  653.             return self.next()
  654.  
  655.  
  656.  
  657.  
  658. def XML(text):
  659.     parser = XMLTreeBuilder()
  660.     parser.feed(text)
  661.     return parser.close()
  662.  
  663.  
  664. def XMLID(text):
  665.     parser = XMLTreeBuilder()
  666.     parser.feed(text)
  667.     tree = parser.close()
  668.     ids = { }
  669.     for elem in tree.getiterator():
  670.         id = elem.get('id')
  671.         if id:
  672.             ids[id] = elem
  673.             continue
  674.     
  675.     return (tree, ids)
  676.  
  677. fromstring = XML
  678.  
  679. def tostring(element, encoding = None):
  680.     
  681.     class dummy:
  682.         pass
  683.  
  684.     data = []
  685.     file = dummy()
  686.     file.write = data.append
  687.     ElementTree(element).write(file, encoding)
  688.     return string.join(data, '')
  689.  
  690.  
  691. class TreeBuilder:
  692.     
  693.     def __init__(self, element_factory = None):
  694.         self._data = []
  695.         self._elem = []
  696.         self._last = None
  697.         self._tail = None
  698.         if element_factory is None:
  699.             element_factory = _ElementInterface
  700.         
  701.         self._factory = element_factory
  702.  
  703.     
  704.     def close(self):
  705.         if not len(self._elem) == 0:
  706.             raise AssertionError, 'missing end tags'
  707.         if not self._last != None:
  708.             raise AssertionError, 'missing toplevel element'
  709.         return self._last
  710.  
  711.     
  712.     def _flush(self):
  713.         if self._data:
  714.             if self._last is not None:
  715.                 text = string.join(self._data, '')
  716.                 if self._tail:
  717.                     if not self._last.tail is None:
  718.                         raise AssertionError, 'internal error (tail)'
  719.                     self._last.tail = text
  720.                 elif not self._last.text is None:
  721.                     raise AssertionError, 'internal error (text)'
  722.                 self._last.text = text
  723.             
  724.             self._data = []
  725.         
  726.  
  727.     
  728.     def data(self, data):
  729.         self._data.append(data)
  730.  
  731.     
  732.     def start(self, tag, attrs):
  733.         self._flush()
  734.         self._last = elem = self._factory(tag, attrs)
  735.         if self._elem:
  736.             self._elem[-1].append(elem)
  737.         
  738.         self._elem.append(elem)
  739.         self._tail = 0
  740.         return elem
  741.  
  742.     
  743.     def end(self, tag):
  744.         self._flush()
  745.         self._last = self._elem.pop()
  746.         if not self._last.tag == tag:
  747.             raise AssertionError, 'end tag mismatch (expected %s, got %s)' % (self._last.tag, tag)
  748.         self._tail = 1
  749.         return self._last
  750.  
  751.  
  752.  
  753. class XMLTreeBuilder:
  754.     
  755.     def __init__(self, html = 0, target = None):
  756.         
  757.         try:
  758.             expat = expat
  759.             import xml.parsers
  760.         except ImportError:
  761.             raise ImportError('No module named expat; use SimpleXMLTreeBuilder instead')
  762.  
  763.         self._parser = parser = expat.ParserCreate(None, '}')
  764.         if target is None:
  765.             target = TreeBuilder()
  766.         
  767.         self._target = target
  768.         self._names = { }
  769.         parser.DefaultHandlerExpand = self._default
  770.         parser.StartElementHandler = self._start
  771.         parser.EndElementHandler = self._end
  772.         parser.CharacterDataHandler = self._data
  773.         
  774.         try:
  775.             self._parser.buffer_text = 1
  776.         except AttributeError:
  777.             pass
  778.  
  779.         
  780.         try:
  781.             self._parser.ordered_attributes = 1
  782.             self._parser.specified_attributes = 1
  783.             parser.StartElementHandler = self._start_list
  784.         except AttributeError:
  785.             pass
  786.  
  787.         encoding = None
  788.         if not parser.returns_unicode:
  789.             encoding = 'utf-8'
  790.         
  791.         self._doctype = None
  792.         self.entity = { }
  793.  
  794.     
  795.     def _fixtext(self, text):
  796.         
  797.         try:
  798.             return _encode(text, 'ascii')
  799.         except UnicodeError:
  800.             return text
  801.  
  802.  
  803.     
  804.     def _fixname(self, key):
  805.         
  806.         try:
  807.             name = self._names[key]
  808.         except KeyError:
  809.             name = key
  810.             if '}' in name:
  811.                 name = '{' + name
  812.             
  813.             self._names[key] = name = self._fixtext(name)
  814.  
  815.         return name
  816.  
  817.     
  818.     def _start(self, tag, attrib_in):
  819.         fixname = self._fixname
  820.         tag = fixname(tag)
  821.         attrib = { }
  822.         for key, value in attrib_in.items():
  823.             attrib[fixname(key)] = self._fixtext(value)
  824.         
  825.         return self._target.start(tag, attrib)
  826.  
  827.     
  828.     def _start_list(self, tag, attrib_in):
  829.         fixname = self._fixname
  830.         tag = fixname(tag)
  831.         attrib = { }
  832.         if attrib_in:
  833.             for i in range(0, len(attrib_in), 2):
  834.                 attrib[fixname(attrib_in[i])] = self._fixtext(attrib_in[i + 1])
  835.             
  836.         
  837.         return self._target.start(tag, attrib)
  838.  
  839.     
  840.     def _data(self, text):
  841.         return self._target.data(self._fixtext(text))
  842.  
  843.     
  844.     def _end(self, tag):
  845.         return self._target.end(self._fixname(tag))
  846.  
  847.     
  848.     def _default(self, text):
  849.         prefix = text[:1]
  850.         if prefix == '&':
  851.             
  852.             try:
  853.                 self._target.data(self.entity[text[1:-1]])
  854.             except KeyError:
  855.                 expat = expat
  856.                 import xml.parsers
  857.                 raise expat.error('undefined entity %s: line %d, column %d' % (text, self._parser.ErrorLineNumber, self._parser.ErrorColumnNumber))
  858.             except:
  859.                 None<EXCEPTION MATCH>KeyError
  860.             
  861.  
  862.         None<EXCEPTION MATCH>KeyError
  863.         if prefix == '<' and text[:9] == '<!DOCTYPE':
  864.             self._doctype = []
  865.         elif self._doctype is not None:
  866.             if prefix == '>':
  867.                 self._doctype = None
  868.                 return None
  869.             text = string.strip(text)
  870.             if not text:
  871.                 return None
  872.             self._doctype.append(text)
  873.             n = len(self._doctype)
  874.             if n > 2:
  875.                 type = self._doctype[1]
  876.                 if type == 'PUBLIC' and n == 4:
  877.                     (name, type, pubid, system) = self._doctype
  878.                 elif type == 'SYSTEM' and n == 3:
  879.                     (name, type, system) = self._doctype
  880.                     pubid = None
  881.                 else:
  882.                     return None
  883.                 if prefix == '>':
  884.                     pubid = pubid[1:-1]
  885.                 
  886.                 self.doctype(name, pubid, system[1:-1])
  887.                 self._doctype = None
  888.             
  889.         
  890.  
  891.     
  892.     def doctype(self, name, pubid, system):
  893.         pass
  894.  
  895.     
  896.     def feed(self, data):
  897.         self._parser.Parse(data, 0)
  898.  
  899.     
  900.     def close(self):
  901.         self._parser.Parse('', 1)
  902.         tree = self._target.close()
  903.         del self._target
  904.         del self._parser
  905.         return tree
  906.  
  907.  
  908.