home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / HTMLParser.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  10.8 KB  |  373 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''A parser for HTML and XHTML.'''
  5. import markupbase
  6. import re
  7. interesting_normal = re.compile('[&<]')
  8. interesting_cdata = re.compile('<(/|\\Z)')
  9. incomplete = re.compile('&[a-zA-Z#]')
  10. entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
  11. charref = re.compile('&#(?:[0-9]+|[xX][0-9a-fA-F]+)[^0-9a-fA-F]')
  12. starttagopen = re.compile('<[a-zA-Z]')
  13. piclose = re.compile('>')
  14. commentclose = re.compile('--\\s*>')
  15. tagfind = re.compile('[a-zA-Z][-.a-zA-Z0-9:_]*')
  16. attrfind = re.compile('\\s*([a-zA-Z_][-.:a-zA-Z_0-9]*)(\\s*=\\s*(\\\'[^\\\']*\\\'|"[^"]*"|[-a-zA-Z0-9./,:;+*%?!&$\\(\\)_#=~@]*))?')
  17. locatestarttagend = re.compile('\n  <[a-zA-Z][-.a-zA-Z0-9:_]*          # tag name\n  (?:\\s+                             # whitespace before attribute name\n    (?:[a-zA-Z_][-.:a-zA-Z0-9_]*     # attribute name\n      (?:\\s*=\\s*                     # value indicator\n        (?:\'[^\']*\'                   # LITA-enclosed value\n          |\\"[^\\"]*\\"                # LIT-enclosed value\n          |[^\'\\">\\s]+                # bare value\n         )\n       )?\n     )\n   )*\n  \\s*                                # trailing whitespace\n', re.VERBOSE)
  18. endendtag = re.compile('>')
  19. endtagfind = re.compile('</\\s*([a-zA-Z][-.a-zA-Z0-9:_]*)\\s*>')
  20.  
  21. class HTMLParseError(Exception):
  22.     '''Exception raised for all parse errors.'''
  23.     
  24.     def __init__(self, msg, position = (None, None)):
  25.         if not msg:
  26.             raise AssertionError
  27.         self.msg = msg
  28.         self.lineno = position[0]
  29.         self.offset = position[1]
  30.  
  31.     
  32.     def __str__(self):
  33.         result = self.msg
  34.         if self.lineno is not None:
  35.             result = result + ', at line %d' % self.lineno
  36.         
  37.         if self.offset is not None:
  38.             result = result + ', column %d' % (self.offset + 1)
  39.         
  40.         return result
  41.  
  42.  
  43.  
  44. class HTMLParser(markupbase.ParserBase):
  45.     '''Find tags and other markup and call handler functions.
  46.  
  47.     Usage:
  48.         p = HTMLParser()
  49.         p.feed(data)
  50.         ...
  51.         p.close()
  52.  
  53.     Start tags are handled by calling self.handle_starttag() or
  54.     self.handle_startendtag(); end tags by self.handle_endtag().  The
  55.     data between tags is passed from the parser to the derived class
  56.     by calling self.handle_data() with the data as argument (the data
  57.     may be split up in arbitrary chunks).  Entity references are
  58.     passed by calling self.handle_entityref() with the entity
  59.     reference as the argument.  Numeric character references are
  60.     passed to self.handle_charref() with the string containing the
  61.     reference as the argument.
  62.     '''
  63.     CDATA_CONTENT_ELEMENTS = ('script', 'style')
  64.     
  65.     def __init__(self):
  66.         '''Initialize and reset this instance.'''
  67.         self.reset()
  68.  
  69.     
  70.     def reset(self):
  71.         '''Reset this instance.  Loses all unprocessed data.'''
  72.         self.rawdata = ''
  73.         self.lasttag = '???'
  74.         self.interesting = interesting_normal
  75.         markupbase.ParserBase.reset(self)
  76.  
  77.     
  78.     def feed(self, data):
  79.         """Feed data to the parser.
  80.  
  81.         Call this as often as you want, with as little or as much text
  82.         as you want (may include '
  83. ').
  84.         """
  85.         self.rawdata = self.rawdata + data
  86.         self.goahead(0)
  87.  
  88.     
  89.     def close(self):
  90.         '''Handle any buffered data.'''
  91.         self.goahead(1)
  92.  
  93.     
  94.     def error(self, message):
  95.         raise HTMLParseError(message, self.getpos())
  96.  
  97.     __starttag_text = None
  98.     
  99.     def get_starttag_text(self):
  100.         """Return full source of start tag: '<...>'."""
  101.         return self._HTMLParser__starttag_text
  102.  
  103.     
  104.     def set_cdata_mode(self):
  105.         self.interesting = interesting_cdata
  106.  
  107.     
  108.     def clear_cdata_mode(self):
  109.         self.interesting = interesting_normal
  110.  
  111.     
  112.     def goahead(self, end):
  113.         rawdata = self.rawdata
  114.         i = 0
  115.         n = len(rawdata)
  116.         while i < n:
  117.             match = self.interesting.search(rawdata, i)
  118.             if match:
  119.                 j = match.start()
  120.             else:
  121.                 j = n
  122.             if i < j:
  123.                 self.handle_data(rawdata[i:j])
  124.             
  125.             i = self.updatepos(i, j)
  126.             if i == n:
  127.                 break
  128.             
  129.             startswith = rawdata.startswith
  130.             if startswith('<', i):
  131.                 if starttagopen.match(rawdata, i):
  132.                     k = self.parse_starttag(i)
  133.                 elif startswith('</', i):
  134.                     k = self.parse_endtag(i)
  135.                 elif startswith('<!--', i):
  136.                     k = self.parse_comment(i)
  137.                 elif startswith('<?', i):
  138.                     k = self.parse_pi(i)
  139.                 elif startswith('<!', i):
  140.                     k = self.parse_declaration(i)
  141.                 elif i + 1 < n:
  142.                     self.handle_data('<')
  143.                     k = i + 1
  144.                 else:
  145.                     break
  146.                 if k < 0:
  147.                     if end:
  148.                         self.error('EOF in middle of construct')
  149.                     
  150.                     break
  151.                 
  152.                 i = self.updatepos(i, k)
  153.                 continue
  154.             if startswith('&#', i):
  155.                 match = charref.match(rawdata, i)
  156.                 if match:
  157.                     name = match.group()[2:-1]
  158.                     self.handle_charref(name)
  159.                     k = match.end()
  160.                     if not startswith(';', k - 1):
  161.                         k = k - 1
  162.                     
  163.                     i = self.updatepos(i, k)
  164.                     continue
  165.                 else:
  166.                     break
  167.             match
  168.             if startswith('&', i):
  169.                 match = entityref.match(rawdata, i)
  170.                 if match:
  171.                     name = match.group(1)
  172.                     self.handle_entityref(name)
  173.                     k = match.end()
  174.                     if not startswith(';', k - 1):
  175.                         k = k - 1
  176.                     
  177.                     i = self.updatepos(i, k)
  178.                     continue
  179.                 
  180.                 match = incomplete.match(rawdata, i)
  181.                 if match:
  182.                     if end and match.group() == rawdata[i:]:
  183.                         self.error('EOF in middle of entity or char ref')
  184.                     
  185.                     break
  186.                 elif i + 1 < n:
  187.                     self.handle_data('&')
  188.                     i = self.updatepos(i, i + 1)
  189.                 else:
  190.                     break
  191.             match
  192.             if not 0:
  193.                 raise AssertionError, 'interesting.search() lied'
  194.         if end and i < n:
  195.             self.handle_data(rawdata[i:n])
  196.             i = self.updatepos(i, n)
  197.         
  198.         self.rawdata = rawdata[i:]
  199.  
  200.     
  201.     def parse_pi(self, i):
  202.         rawdata = self.rawdata
  203.         if not rawdata[i:i + 2] == '<?':
  204.             raise AssertionError, 'unexpected call to parse_pi()'
  205.         match = piclose.search(rawdata, i + 2)
  206.         if not match:
  207.             return -1
  208.         
  209.         j = match.start()
  210.         self.handle_pi(rawdata[i + 2:j])
  211.         j = match.end()
  212.         return j
  213.  
  214.     
  215.     def parse_starttag(self, i):
  216.         self._HTMLParser__starttag_text = None
  217.         endpos = self.check_for_whole_start_tag(i)
  218.         if endpos < 0:
  219.             return endpos
  220.         
  221.         rawdata = self.rawdata
  222.         self._HTMLParser__starttag_text = rawdata[i:endpos]
  223.         attrs = []
  224.         match = tagfind.match(rawdata, i + 1)
  225.         if not match:
  226.             raise AssertionError, 'unexpected call to parse_starttag()'
  227.         k = match.end()
  228.         self.lasttag = tag = rawdata[i + 1:k].lower()
  229.         while k < endpos:
  230.             m = attrfind.match(rawdata, k)
  231.             if not m:
  232.                 break
  233.             
  234.             (attrname, rest, attrvalue) = m.group(1, 2, 3)
  235.             if not rest:
  236.                 attrvalue = None
  237.             elif "'" == "'":
  238.                 pass
  239.             elif not "'" == attrvalue[-1:]:
  240.                 if '"' == '"':
  241.                     pass
  242.                 elif '"' == attrvalue[-1:]:
  243.                     attrvalue = attrvalue[1:-1]
  244.                     attrvalue = self.unescape(attrvalue)
  245.                 
  246.             attrs.append((attrname.lower(), attrvalue))
  247.             k = m.end()
  248.             continue
  249.             attrvalue[:1]
  250.         end = rawdata[k:endpos].strip()
  251.         if end not in ('>', '/>'):
  252.             (lineno, offset) = self.getpos()
  253.             if '\n' in self._HTMLParser__starttag_text:
  254.                 lineno = lineno + self._HTMLParser__starttag_text.count('\n')
  255.                 offset = len(self._HTMLParser__starttag_text) - self._HTMLParser__starttag_text.rfind('\n')
  256.             else:
  257.                 offset = offset + len(self._HTMLParser__starttag_text)
  258.             self.error('junk characters in start tag: %r' % (rawdata[k:endpos][:20],))
  259.         
  260.         if end.endswith('/>'):
  261.             self.handle_startendtag(tag, attrs)
  262.         else:
  263.             self.handle_starttag(tag, attrs)
  264.             if tag in self.CDATA_CONTENT_ELEMENTS:
  265.                 self.set_cdata_mode()
  266.             
  267.         return endpos
  268.  
  269.     
  270.     def check_for_whole_start_tag(self, i):
  271.         rawdata = self.rawdata
  272.         m = locatestarttagend.match(rawdata, i)
  273.         if m:
  274.             j = m.end()
  275.             next = rawdata[j:j + 1]
  276.             if next == '>':
  277.                 return j + 1
  278.             
  279.             if next == '/':
  280.                 if rawdata.startswith('/>', j):
  281.                     return j + 2
  282.                 
  283.                 if rawdata.startswith('/', j):
  284.                     return -1
  285.                 
  286.                 self.updatepos(i, j + 1)
  287.                 self.error('malformed empty start tag')
  288.             
  289.             if next == '':
  290.                 return -1
  291.             
  292.             if next in 'abcdefghijklmnopqrstuvwxyz=/ABCDEFGHIJKLMNOPQRSTUVWXYZ':
  293.                 return -1
  294.             
  295.             self.updatepos(i, j)
  296.             self.error('malformed start tag')
  297.         
  298.         raise AssertionError('we should not get here!')
  299.  
  300.     
  301.     def parse_endtag(self, i):
  302.         rawdata = self.rawdata
  303.         if not rawdata[i:i + 2] == '</':
  304.             raise AssertionError, 'unexpected call to parse_endtag'
  305.         match = endendtag.search(rawdata, i + 1)
  306.         if not match:
  307.             return -1
  308.         
  309.         j = match.end()
  310.         match = endtagfind.match(rawdata, i)
  311.         if not match:
  312.             self.error('bad end tag: %r' % (rawdata[i:j],))
  313.         
  314.         tag = match.group(1)
  315.         self.handle_endtag(tag.lower())
  316.         self.clear_cdata_mode()
  317.         return j
  318.  
  319.     
  320.     def handle_startendtag(self, tag, attrs):
  321.         self.handle_starttag(tag, attrs)
  322.         self.handle_endtag(tag)
  323.  
  324.     
  325.     def handle_starttag(self, tag, attrs):
  326.         pass
  327.  
  328.     
  329.     def handle_endtag(self, tag):
  330.         pass
  331.  
  332.     
  333.     def handle_charref(self, name):
  334.         pass
  335.  
  336.     
  337.     def handle_entityref(self, name):
  338.         pass
  339.  
  340.     
  341.     def handle_data(self, data):
  342.         pass
  343.  
  344.     
  345.     def handle_comment(self, data):
  346.         pass
  347.  
  348.     
  349.     def handle_decl(self, decl):
  350.         pass
  351.  
  352.     
  353.     def handle_pi(self, data):
  354.         pass
  355.  
  356.     
  357.     def unknown_decl(self, data):
  358.         self.error('unknown declaration: %r' % (data,))
  359.  
  360.     
  361.     def unescape(self, s):
  362.         if '&' not in s:
  363.             return s
  364.         
  365.         s = s.replace('<', '<')
  366.         s = s.replace('>', '>')
  367.         s = s.replace(''', "'")
  368.         s = s.replace('"', '"')
  369.         s = s.replace('&', '&')
  370.         return s
  371.  
  372.  
  373.