home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2004 #2 / K-CD-2-2004.ISO / OpenOffice Sv / f_0397 / python-core-2.2.2 / lib / xml / sax / expatreader.py < prev    next >
Encoding:
Python Source  |  2003-07-18  |  10.9 KB  |  334 lines
  1. """
  2. SAX driver for the Pyexpat C module.  This driver works with
  3. pyexpat.__version__ == '2.22'.
  4. """
  5.  
  6. version = "0.20"
  7.  
  8. from xml.sax._exceptions import *
  9.  
  10. # xml.parsers.expat does not raise ImportError in Jython
  11. import sys
  12. if sys.platform[:4] == "java":
  13.     raise SAXReaderNotAvailable("expat not available in Java", None)
  14. del sys
  15.  
  16. try:
  17.     from xml.parsers import expat
  18. except ImportError:
  19.     raise SAXReaderNotAvailable("expat not supported", None)
  20. else:
  21.     if not hasattr(expat, "ParserCreate"):
  22.         raise SAXReaderNotAvailable("expat not supported", None)
  23. from xml.sax import xmlreader, saxutils, handler
  24.  
  25. AttributesImpl = xmlreader.AttributesImpl
  26. AttributesNSImpl = xmlreader.AttributesNSImpl
  27.  
  28. import string
  29. import weakref
  30.  
  31. # --- ExpatLocator
  32.  
  33. class ExpatLocator(xmlreader.Locator):
  34.     """Locator for use with the ExpatParser class.
  35.  
  36.     This uses a weak reference to the parser object to avoid creating
  37.     a circular reference between the parser and the content handler.
  38.     """
  39.     def __init__(self, parser):
  40.         self._ref = weakref.ref(parser)
  41.  
  42.     def getColumnNumber(self):
  43.         parser = self._ref()
  44.         if parser is None or parser._parser is None:
  45.             return None
  46.         return parser._parser.ErrorColumnNumber
  47.  
  48.     def getLineNumber(self):
  49.         parser = self._ref()
  50.         if parser is None or parser._parser is None:
  51.             return 1
  52.         return parser._parser.ErrorLineNumber
  53.  
  54.     def getPublicId(self):
  55.         parser = self._ref()
  56.         if parser is None:
  57.             return None
  58.         return parser._source.getPublicId()
  59.  
  60.     def getSystemId(self):
  61.         parser = self._ref()
  62.         if parser is None:
  63.             return None
  64.         return parser._source.getSystemId()
  65.  
  66.  
  67. # --- ExpatParser
  68.  
  69. class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
  70.     "SAX driver for the Pyexpat C module."
  71.  
  72.     def __init__(self, namespaceHandling=0, bufsize=2**16-20):
  73.         xmlreader.IncrementalParser.__init__(self, bufsize)
  74.         self._source = xmlreader.InputSource()
  75.         self._parser = None
  76.         self._namespaces = namespaceHandling
  77.         self._lex_handler_prop = None
  78.         self._parsing = 0
  79.         self._entity_stack = []
  80.         self._ns_stack = []
  81.  
  82.     # XMLReader methods
  83.  
  84.     def parse(self, source):
  85.         "Parse an XML document from a URL or an InputSource."
  86.         source = saxutils.prepare_input_source(source)
  87.  
  88.         self._source = source
  89.         self.reset()
  90.         self._cont_handler.setDocumentLocator(ExpatLocator(self))
  91.         xmlreader.IncrementalParser.parse(self, source)
  92.  
  93.     def prepareParser(self, source):
  94.         if source.getSystemId() != None:
  95.             self._parser.SetBase(source.getSystemId())
  96.  
  97.     # Redefined setContentHandle to allow changing handlers during parsing
  98.  
  99.     def setContentHandler(self, handler):
  100.         xmlreader.IncrementalParser.setContentHandler(self, handler)
  101.         if self._parsing:
  102.             self._reset_cont_handler()
  103.  
  104.     def getFeature(self, name):
  105.         if name == handler.feature_namespaces:
  106.             return self._namespaces
  107.         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  108.  
  109.     def setFeature(self, name, state):
  110.         if self._parsing:
  111.             raise SAXNotSupportedException("Cannot set features while parsing")
  112.         if name == handler.feature_namespaces:
  113.             self._namespaces = state
  114.         else:
  115.             raise SAXNotRecognizedException("Feature '%s' not recognized" %
  116.                                             name)
  117.  
  118.     def getProperty(self, name):
  119.         if name == handler.property_lexical_handler:
  120.             return self._lex_handler_prop
  121.         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  122.  
  123.     def setProperty(self, name, value):
  124.         if name == handler.property_lexical_handler:
  125.             self._lex_handler_prop = value
  126.             if self._parsing:
  127.                 self._reset_lex_handler_prop()
  128.         else:
  129.             raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  130.  
  131.     # IncrementalParser methods
  132.  
  133.     def feed(self, data, isFinal = 0):
  134.         if not self._parsing:
  135.             self.reset()
  136.             self._parsing = 1
  137.             self._cont_handler.startDocument()
  138.  
  139.         try:
  140.             # The isFinal parameter is internal to the expat reader.
  141.             # If it is set to true, expat will check validity of the entire
  142.             # document. When feeding chunks, they are not normally final -
  143.             # except when invoked from close.
  144.             self._parser.Parse(data, isFinal)
  145.         except expat.error:
  146.             error_code = self._parser.ErrorCode
  147.             exc = SAXParseException(expat.ErrorString(error_code), None, self)
  148.             # FIXME: when to invoke error()?
  149.             self._err_handler.fatalError(exc)
  150.  
  151.     def close(self):
  152.         if self._entity_stack:
  153.             # If we are completing an external entity, do nothing here
  154.             return
  155.         self.feed("", isFinal = 1)
  156.         self._cont_handler.endDocument()
  157.         self._parsing = 0
  158.         # break cycle created by expat handlers pointing to our methods
  159.         self._parser = None
  160.  
  161.     def _reset_cont_handler(self):
  162.         self._parser.ProcessingInstructionHandler = \
  163.                                     self._cont_handler.processingInstruction
  164.         self._parser.CharacterDataHandler = self._cont_handler.characters
  165.  
  166.     def _reset_lex_handler_prop(self):
  167.         self._parser.CommentHandler = self._lex_handler_prop.comment
  168.         self._parser.StartCdataSectionHandler = self._lex_handler_prop.startCDATA
  169.         self._parser.EndCdataSectionHandler = self._lex_handler_prop.endCDATA
  170.  
  171.     def reset(self):
  172.         if self._namespaces:
  173.             self._parser = expat.ParserCreate(None, " ")
  174.             self._parser.StartElementHandler = self.start_element_ns
  175.             self._parser.EndElementHandler = self.end_element_ns
  176.         else:
  177.             self._parser = expat.ParserCreate()
  178.             self._parser.StartElementHandler = self.start_element
  179.             self._parser.EndElementHandler = self.end_element
  180.  
  181.         self._reset_cont_handler()
  182.         self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
  183.         self._parser.NotationDeclHandler = self.notation_decl
  184.         self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
  185.         self._parser.EndNamespaceDeclHandler = self.end_namespace_decl
  186.  
  187.         self._decl_handler_prop = None
  188.         if self._lex_handler_prop:
  189.             self._reset_lex_handler_prop()
  190. #         self._parser.DefaultHandler =
  191. #         self._parser.DefaultHandlerExpand =
  192. #         self._parser.NotStandaloneHandler =
  193.         self._parser.ExternalEntityRefHandler = self.external_entity_ref
  194.  
  195.         self._parsing = 0
  196.         self._entity_stack = []
  197.  
  198.     # Locator methods
  199.  
  200.     def getColumnNumber(self):
  201.         if self._parser is None:
  202.             return None
  203.         return self._parser.ErrorColumnNumber
  204.  
  205.     def getLineNumber(self):
  206.         if self._parser is None:
  207.             return 1
  208.         return self._parser.ErrorLineNumber
  209.  
  210.     def getPublicId(self):
  211.         return self._source.getPublicId()
  212.  
  213.     def getSystemId(self):
  214.         return self._source.getSystemId()
  215.  
  216.     # event handlers
  217.     def start_element(self, name, attrs):
  218.         self._cont_handler.startElement(name, AttributesImpl(attrs))
  219.  
  220.     def end_element(self, name):
  221.         self._cont_handler.endElement(name)
  222.  
  223.     def start_element_ns(self, name, attrs):
  224.         pair = string.split(name)
  225.         if len(pair) == 1:
  226.             pair = (None, name)
  227.             qname = name
  228.         else:
  229.             pair = tuple(pair)
  230.             qname = pair[1]
  231.             if self._ns_stack:
  232.                 prefix = self._ns_stack[-1][pair[0]][-1]
  233.                 if prefix:
  234.                     qname = "%s:%s" % (prefix, pair[1])
  235.  
  236.         newattrs = {}
  237.         qnames = {}
  238.         for (aname, value) in attrs.items():
  239.             apair = string.split(aname)
  240.             if len(apair) == 1:
  241.                 apair = (None, aname)
  242.                 aqname = aname
  243.             else:
  244.                 apair = tuple(apair)
  245.                 # XXX need to guess the prefix
  246.                 prefix = self._ns_stack[-1][apair[0]][-1]
  247.                 aqname = "%s:%s" % (prefix, apair[1])
  248.  
  249.             newattrs[apair] = value
  250.             qnames[apair] = aqname
  251.  
  252.         self._cont_handler.startElementNS(pair, qname,
  253.                                           AttributesNSImpl(newattrs, qnames))
  254.  
  255.     def end_element_ns(self, name):
  256.         pair = string.split(name)
  257.         if len(pair) == 1:
  258.             pair = (None, name)
  259.             qname = name
  260.         else:
  261.             pair = tuple(pair)
  262.             qname = pair[1]
  263.             if self._ns_stack:
  264.                 prefix = self._ns_stack[-1][pair[0]][-1]
  265.                 if prefix:
  266.                     qname = "%s:%s" % (prefix, pair[1])
  267.  
  268.         self._cont_handler.endElementNS(pair, qname)
  269.  
  270.     # this is not used (call directly to ContentHandler)
  271.     def processing_instruction(self, target, data):
  272.         self._cont_handler.processingInstruction(target, data)
  273.  
  274.     # this is not used (call directly to ContentHandler)
  275.     def character_data(self, data):
  276.         self._cont_handler.characters(data)
  277.  
  278.     def start_namespace_decl(self, prefix, uri):
  279.         if self._ns_stack:
  280.             d = self._ns_stack[-1].copy()
  281.             if d.has_key(uri):
  282.                 L = d[uri][:]
  283.                 d[uri] = L
  284.                 L.append(prefix)
  285.             else:
  286.                 d[uri] = [prefix]
  287.         else:
  288.             d = {uri: [prefix]}
  289.         self._ns_stack.append(d)
  290.         self._cont_handler.startPrefixMapping(prefix, uri)
  291.  
  292.     def end_namespace_decl(self, prefix):
  293.         del self._ns_stack[-1]
  294.         self._cont_handler.endPrefixMapping(prefix)
  295.  
  296.     def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
  297.         self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)
  298.  
  299.     def notation_decl(self, name, base, sysid, pubid):
  300.         self._dtd_handler.notationDecl(name, pubid, sysid)
  301.  
  302.     def external_entity_ref(self, context, base, sysid, pubid):
  303.         source = self._ent_handler.resolveEntity(pubid, sysid)
  304.         source = saxutils.prepare_input_source(source,
  305.                                                self._source.getSystemId() or
  306.                                                "")
  307.  
  308.         self._entity_stack.append((self._parser, self._source))
  309.         self._parser = self._parser.ExternalEntityParserCreate(context)
  310.         self._source = source
  311.  
  312.         try:
  313.             xmlreader.IncrementalParser.parse(self, source)
  314.         except:
  315.             return 0  # FIXME: save error info here?
  316.  
  317.         (self._parser, self._source) = self._entity_stack[-1]
  318.         del self._entity_stack[-1]
  319.         return 1
  320.  
  321. # ---
  322.  
  323. def create_parser(*args, **kwargs):
  324.     return apply(ExpatParser, args, kwargs)
  325.  
  326. # ---
  327.  
  328. if __name__ == "__main__":
  329.     import xml.sax
  330.     p = create_parser()
  331.     p.setContentHandler(xml.sax.XMLGenerator())
  332.     p.setErrorHandler(xml.sax.ErrorHandler())
  333.     p.parse("../../../hamlet.xml")
  334.