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