home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / expatreader.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-12-30  |  18.9 KB  |  418 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.3)
  3.  
  4. """
  5. SAX driver for the pyexpat C module.  This driver works with
  6. pyexpat.__version__ == '2.22'.
  7. """
  8. version = '0.20'
  9. from xml.sax._exceptions import *
  10. from xml.sax.handler import feature_validation, feature_namespaces
  11. from xml.sax.handler import feature_namespace_prefixes
  12. from xml.sax.handler import feature_external_ges, feature_external_pes
  13. from xml.sax.handler import feature_string_interning
  14. from xml.sax.handler import property_xml_string, property_interning_dict
  15. import sys
  16. if sys.platform[:4] == 'java':
  17.     raise SAXReaderNotAvailable('expat not available in Java', None)
  18.  
  19. del sys
  20.  
  21. try:
  22.     from xml.parsers import expat
  23. except ImportError:
  24.     raise SAXReaderNotAvailable('expat not supported', None)
  25.  
  26. if not hasattr(expat, 'ParserCreate'):
  27.     raise SAXReaderNotAvailable('expat not supported', None)
  28.  
  29. from xml.sax import xmlreader, saxutils, handler
  30. AttributesImpl = xmlreader.AttributesImpl
  31. AttributesNSImpl = xmlreader.AttributesNSImpl
  32.  
  33. try:
  34.     import _weakref
  35. except ImportError:
  36.     
  37.     def _mkproxy(o):
  38.         return o
  39.  
  40.  
  41. import weakref
  42. _mkproxy = weakref.proxy
  43. del weakref
  44. del _weakref
  45.  
  46. class ExpatLocator(xmlreader.Locator):
  47.     '''Locator for use with the ExpatParser class.
  48.  
  49.     This uses a weak reference to the parser object to avoid creating
  50.     a circular reference between the parser and the content handler.
  51.     '''
  52.     
  53.     def __init__(self, parser):
  54.         self._ref = _mkproxy(parser)
  55.  
  56.     
  57.     def getColumnNumber(self):
  58.         parser = self._ref
  59.         if parser._parser is None:
  60.             return None
  61.         
  62.         return parser._parser.ErrorColumnNumber
  63.  
  64.     
  65.     def getLineNumber(self):
  66.         parser = self._ref
  67.         if parser._parser is None:
  68.             return 1
  69.         
  70.         return parser._parser.ErrorLineNumber
  71.  
  72.     
  73.     def getPublicId(self):
  74.         parser = self._ref
  75.         if parser is None:
  76.             return None
  77.         
  78.         return parser._source.getPublicId()
  79.  
  80.     
  81.     def getSystemId(self):
  82.         parser = self._ref
  83.         if parser is None:
  84.             return None
  85.         
  86.         return parser._source.getSystemId()
  87.  
  88.  
  89.  
  90. class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
  91.     '''SAX driver for the pyexpat C module.'''
  92.     
  93.     def __init__(self, namespaceHandling = 0, bufsize = 2 ** 16 - 20):
  94.         xmlreader.IncrementalParser.__init__(self, bufsize)
  95.         self._source = xmlreader.InputSource()
  96.         self._parser = None
  97.         self._namespaces = namespaceHandling
  98.         self._lex_handler_prop = None
  99.         self._parsing = 0
  100.         self._entity_stack = []
  101.         self._external_ges = 1
  102.         self._interning = None
  103.  
  104.     
  105.     def parse(self, source):
  106.         '''Parse an XML document from a URL or an InputSource.'''
  107.         source = saxutils.prepare_input_source(source)
  108.         self._source = source
  109.         self.reset()
  110.         self._cont_handler.setDocumentLocator(ExpatLocator(self))
  111.         xmlreader.IncrementalParser.parse(self, source)
  112.  
  113.     
  114.     def prepareParser(self, source):
  115.         if source.getSystemId() != None:
  116.             self._parser.SetBase(source.getSystemId())
  117.         
  118.  
  119.     
  120.     def setContentHandler(self, handler):
  121.         xmlreader.IncrementalParser.setContentHandler(self, handler)
  122.         if self._parsing:
  123.             self._reset_cont_handler()
  124.         
  125.  
  126.     
  127.     def getFeature(self, name):
  128.         if name == feature_namespaces:
  129.             return self._namespaces
  130.         elif name == feature_string_interning:
  131.             return self._interning is not None
  132.         elif name in (feature_validation, feature_external_pes, feature_namespace_prefixes):
  133.             return 0
  134.         elif name == feature_external_ges:
  135.             return self._external_ges
  136.         
  137.         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  138.  
  139.     
  140.     def setFeature(self, name, state):
  141.         if self._parsing:
  142.             raise SAXNotSupportedException('Cannot set features while parsing')
  143.         
  144.         if name == feature_namespaces:
  145.             self._namespaces = state
  146.         elif name == feature_external_ges:
  147.             self._external_ges = state
  148.         elif name == feature_string_interning:
  149.             if state:
  150.                 if self._interning is None:
  151.                     self._interning = { }
  152.                 
  153.             else:
  154.                 self._interning = None
  155.         elif name == feature_validation:
  156.             if state:
  157.                 raise SAXNotSupportedException('expat does not support validation')
  158.             
  159.         elif name == feature_external_pes:
  160.             if state:
  161.                 raise SAXNotSupportedException('expat does not read external parameter entities')
  162.             
  163.         elif name == feature_namespace_prefixes:
  164.             if state:
  165.                 raise SAXNotSupportedException('expat does not report namespace prefixes')
  166.             
  167.         else:
  168.             raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  169.  
  170.     
  171.     def getProperty(self, name):
  172.         if name == handler.property_lexical_handler:
  173.             return self._lex_handler_prop
  174.         elif name == property_interning_dict:
  175.             return self._interning
  176.         elif name == property_xml_string:
  177.             if self._parser:
  178.                 if hasattr(self._parser, 'GetInputContext'):
  179.                     return self._parser.GetInputContext()
  180.                 else:
  181.                     raise SAXNotRecognizedException('This version of expat does not support getting the XML string')
  182.             else:
  183.                 raise SAXNotSupportedException('XML string cannot be returned when not parsing')
  184.         
  185.         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  186.  
  187.     
  188.     def setProperty(self, name, value):
  189.         if name == handler.property_lexical_handler:
  190.             self._lex_handler_prop = value
  191.             if self._parsing:
  192.                 self._reset_lex_handler_prop()
  193.             
  194.         elif name == property_interning_dict:
  195.             self._interning = value
  196.         elif name == property_xml_string:
  197.             raise SAXNotSupportedException("Property '%s' cannot be set" % name)
  198.         else:
  199.             raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  200.  
  201.     
  202.     def feed(self, data, isFinal = 0):
  203.         if not (self._parsing):
  204.             self.reset()
  205.             self._parsing = 1
  206.             self._cont_handler.startDocument()
  207.         
  208.         
  209.         try:
  210.             self._parser.Parse(data, isFinal)
  211.         except expat.error:
  212.             e = None
  213.             exc = SAXParseException(expat.ErrorString(e.code), e, self)
  214.             self._err_handler.fatalError(exc)
  215.  
  216.  
  217.     
  218.     def close(self):
  219.         if self._entity_stack:
  220.             return None
  221.         
  222.         self.feed('', isFinal = 1)
  223.         self._cont_handler.endDocument()
  224.         self._parsing = 0
  225.         self._parser = None
  226.  
  227.     
  228.     def _reset_cont_handler(self):
  229.         self._parser.ProcessingInstructionHandler = self._cont_handler.processingInstruction
  230.         self._parser.CharacterDataHandler = self._cont_handler.characters
  231.  
  232.     
  233.     def _reset_lex_handler_prop(self):
  234.         lex = self._lex_handler_prop
  235.         parser = self._parser
  236.         if lex is None:
  237.             parser.CommentHandler = None
  238.             parser.StartCdataSectionHandler = None
  239.             parser.EndCdataSectionHandler = None
  240.             parser.StartDoctypeDeclHandler = None
  241.             parser.EndDoctypeDeclHandler = None
  242.         else:
  243.             parser.CommentHandler = lex.comment
  244.             parser.StartCdataSectionHandler = lex.startCDATA
  245.             parser.EndCdataSectionHandler = lex.endCDATA
  246.             parser.StartDoctypeDeclHandler = self.start_doctype_decl
  247.             parser.EndDoctypeDeclHandler = lex.endDTD
  248.  
  249.     
  250.     def reset(self):
  251.         if self._namespaces:
  252.             self._parser = expat.ParserCreate(None, ' ', intern = self._interning)
  253.             self._parser.namespace_prefixes = 1
  254.             self._parser.StartElementHandler = self.start_element_ns
  255.             self._parser.EndElementHandler = self.end_element_ns
  256.         else:
  257.             self._parser = expat.ParserCreate(intern = self._interning)
  258.             self._parser.StartElementHandler = self.start_element
  259.             self._parser.EndElementHandler = self.end_element
  260.         self._reset_cont_handler()
  261.         self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
  262.         self._parser.NotationDeclHandler = self.notation_decl
  263.         self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
  264.         self._parser.EndNamespaceDeclHandler = self.end_namespace_decl
  265.         self._decl_handler_prop = None
  266.         if self._lex_handler_prop:
  267.             self._reset_lex_handler_prop()
  268.         
  269.         self._parser.ExternalEntityRefHandler = self.external_entity_ref
  270.         
  271.         try:
  272.             self._parser.SkippedEntityHandler = self.skipped_entity_handler
  273.         except AttributeError:
  274.             pass
  275.  
  276.         self._parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
  277.         self._parsing = 0
  278.         self._entity_stack = []
  279.  
  280.     
  281.     def getColumnNumber(self):
  282.         if self._parser is None:
  283.             return None
  284.         
  285.         return self._parser.ErrorColumnNumber
  286.  
  287.     
  288.     def getLineNumber(self):
  289.         if self._parser is None:
  290.             return 1
  291.         
  292.         return self._parser.ErrorLineNumber
  293.  
  294.     
  295.     def getPublicId(self):
  296.         return self._source.getPublicId()
  297.  
  298.     
  299.     def getSystemId(self):
  300.         return self._source.getSystemId()
  301.  
  302.     
  303.     def start_element(self, name, attrs):
  304.         self._cont_handler.startElement(name, AttributesImpl(attrs))
  305.  
  306.     
  307.     def end_element(self, name):
  308.         self._cont_handler.endElement(name)
  309.  
  310.     
  311.     def start_element_ns(self, name, attrs):
  312.         pair = name.split()
  313.         if len(pair) == 1:
  314.             pair = (None, name)
  315.         elif len(pair) == 3:
  316.             pair = (pair[0], pair[1])
  317.         else:
  318.             pair = tuple(pair)
  319.         newattrs = { }
  320.         qnames = { }
  321.         for aname, value in attrs.items():
  322.             parts = aname.split()
  323.             length = len(parts)
  324.             if length == 1:
  325.                 qname = aname
  326.                 apair = (None, aname)
  327.             elif length == 3:
  328.                 qname = '%s:%s' % (parts[2], parts[1])
  329.                 apair = (parts[0], parts[1])
  330.             else:
  331.                 qname = parts[1]
  332.                 apair = tuple(parts)
  333.             newattrs[apair] = value
  334.             qnames[apair] = qname
  335.         
  336.         self._cont_handler.startElementNS(pair, None, AttributesNSImpl(newattrs, qnames))
  337.  
  338.     
  339.     def end_element_ns(self, name):
  340.         pair = name.split()
  341.         if len(pair) == 1:
  342.             pair = (None, name)
  343.         elif len(pair) == 3:
  344.             pair = (pair[0], pair[1])
  345.         else:
  346.             pair = tuple(pair)
  347.         self._cont_handler.endElementNS(pair, None)
  348.  
  349.     
  350.     def processing_instruction(self, target, data):
  351.         self._cont_handler.processingInstruction(target, data)
  352.  
  353.     
  354.     def character_data(self, data):
  355.         self._cont_handler.characters(data)
  356.  
  357.     
  358.     def start_namespace_decl(self, prefix, uri):
  359.         self._cont_handler.startPrefixMapping(prefix, uri)
  360.  
  361.     
  362.     def end_namespace_decl(self, prefix):
  363.         self._cont_handler.endPrefixMapping(prefix)
  364.  
  365.     
  366.     def start_doctype_decl(self, name, pubid, sysid, has_internal_subset):
  367.         self._lex_handler_prop.startDTD(name, pubid, sysid)
  368.  
  369.     
  370.     def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
  371.         self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)
  372.  
  373.     
  374.     def notation_decl(self, name, base, sysid, pubid):
  375.         self._dtd_handler.notationDecl(name, pubid, sysid)
  376.  
  377.     
  378.     def external_entity_ref(self, context, base, sysid, pubid):
  379.         if not (self._external_ges):
  380.             return 1
  381.         
  382.         source = self._ent_handler.resolveEntity(pubid, sysid)
  383.         if not self._source.getSystemId():
  384.             pass
  385.         source = saxutils.prepare_input_source(source, '')
  386.         self._entity_stack.append((self._parser, self._source))
  387.         self._parser = self._parser.ExternalEntityParserCreate(context)
  388.         self._source = source
  389.         
  390.         try:
  391.             xmlreader.IncrementalParser.parse(self, source)
  392.         except:
  393.             return 0
  394.  
  395.         (self._parser, self._source) = self._entity_stack[-1]
  396.         del self._entity_stack[-1]
  397.         return 1
  398.  
  399.     
  400.     def skipped_entity_handler(self, name, is_pe):
  401.         if is_pe:
  402.             name = '%' + name
  403.         
  404.         self._cont_handler.skippedEntity(name)
  405.  
  406.  
  407.  
  408. def create_parser(*args, **kwargs):
  409.     return ExpatParser(*args, **kwargs)
  410.  
  411. if __name__ == '__main__':
  412.     import xml.sax as xml
  413.     p = create_parser()
  414.     p.setContentHandler(xml.sax.XMLGenerator())
  415.     p.setErrorHandler(xml.sax.ErrorHandler())
  416.     p.parse('../../../hamlet.xml')
  417.  
  418.