home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1132 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  14.5 KB  |  557 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import markupbase
  5. import re
  6. __all__ = [
  7.     'SGMLParser',
  8.     'SGMLParseError']
  9. interesting = re.compile('[&<]')
  10. incomplete = re.compile('&([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|<([a-zA-Z][^<>]*|/([a-zA-Z][^<>]*)?|![^<>]*)?')
  11. entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
  12. charref = re.compile('&#(x{0,1}[a-f0-9]+)[^a-f0-9]', re.IGNORECASE)
  13. starttagopen = re.compile('<[>a-zA-Z]')
  14. shorttagopen = re.compile('<[a-zA-Z][-.a-zA-Z0-9]*/')
  15. shorttag = re.compile('<([a-zA-Z][-.a-zA-Z0-9]*)/([^/]*)/')
  16. piclose = re.compile('>')
  17. endbracket = re.compile('[<>]')
  18. tagfind = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*')
  19. attrfind = re.compile('\\s*([a-zA-Z_][-:.a-zA-Z_0-9]*)(\\s*=\\s*(\\\'[^\\\']*\\\'|"[^"]*"|[][\\-a-zA-Z0-9./,:;+*%?!&$\\(\\)_#=~\\\'"@]*))?')
  20.  
  21. class SGMLParseError(RuntimeError):
  22.     pass
  23.  
  24.  
  25. class SGMLParser(markupbase.ParserBase):
  26.     entity_or_charref = re.compile('&(?:([a-zA-Z][-.a-zA-Z0-9]*)|#([0-9]+))(;?)')
  27.     
  28.     def __init__(self, verbose = 0):
  29.         self.verbose = verbose
  30.         self.reset()
  31.  
  32.     
  33.     def reset(self):
  34.         self._SGMLParser__starttag_text = None
  35.         self.rawdata = ''
  36.         self.stack = []
  37.         self.lasttag = '???'
  38.         self.nomoretags = 0
  39.         self.literal = 0
  40.         markupbase.ParserBase.reset(self)
  41.  
  42.     
  43.     def setnomoretags(self):
  44.         self.nomoretags = self.literal = 1
  45.  
  46.     
  47.     def setliteral(self, *args):
  48.         self.literal = 1
  49.  
  50.     
  51.     def feed(self, data):
  52.         self.rawdata = self.rawdata + data
  53.         self.goahead(0)
  54.  
  55.     
  56.     def close(self):
  57.         self.goahead(1)
  58.  
  59.     
  60.     def error(self, message):
  61.         raise SGMLParseError(message)
  62.  
  63.     
  64.     def goahead(self, end):
  65.         rawdata = self.rawdata
  66.         i = 0
  67.         n = len(rawdata)
  68.         while i < n:
  69.             if self.nomoretags:
  70.                 self.handle_data(rawdata[i:n])
  71.                 i = n
  72.                 break
  73.             
  74.             match = interesting.search(rawdata, i)
  75.             if match:
  76.                 j = match.start()
  77.             else:
  78.                 j = n
  79.             if i < j:
  80.                 self.handle_data(rawdata[i:j])
  81.             
  82.             i = j
  83.             if i == n:
  84.                 break
  85.             
  86.             if rawdata[i] == '<':
  87.                 if starttagopen.match(rawdata, i):
  88.                     if self.literal:
  89.                         self.handle_data(rawdata[i])
  90.                         i = i + 1
  91.                         continue
  92.                     
  93.                     k = self.parse_starttag(i)
  94.                     if k < 0:
  95.                         break
  96.                     
  97.                     i = k
  98.                     continue
  99.                 
  100.                 if rawdata.startswith('</', i):
  101.                     k = self.parse_endtag(i)
  102.                     if k < 0:
  103.                         break
  104.                     
  105.                     i = k
  106.                     self.literal = 0
  107.                     continue
  108.                 
  109.                 if self.literal:
  110.                     if n > i + 1:
  111.                         self.handle_data('<')
  112.                         i = i + 1
  113.                         continue
  114.                     break
  115.                     continue
  116.                 
  117.                 if rawdata.startswith('<!--', i):
  118.                     k = self.parse_comment(i)
  119.                     if k < 0:
  120.                         break
  121.                     
  122.                     i = k
  123.                     continue
  124.                 
  125.                 if rawdata.startswith('<?', i):
  126.                     k = self.parse_pi(i)
  127.                     if k < 0:
  128.                         break
  129.                     
  130.                     i = i + k
  131.                     continue
  132.                 
  133.                 if rawdata.startswith('<!', i):
  134.                     k = self.parse_declaration(i)
  135.                     if k < 0:
  136.                         break
  137.                     
  138.                     i = k
  139.                     continue
  140.                 
  141.             elif rawdata[i] == '&':
  142.                 if self.literal:
  143.                     self.handle_data(rawdata[i])
  144.                     i = i + 1
  145.                     continue
  146.                 
  147.                 match = charref.match(rawdata, i)
  148.                 if match:
  149.                     name = match.group(1)
  150.                     self.handle_charref(name)
  151.                     i = match.end(0)
  152.                     if rawdata[i - 1] != ';':
  153.                         i = i - 1
  154.                         continue
  155.                     continue
  156.                 
  157.                 match = entityref.match(rawdata, i)
  158.                 if match:
  159.                     name = match.group(1)
  160.                     self.handle_entityref(name)
  161.                     i = match.end(0)
  162.                     if rawdata[i - 1] != ';':
  163.                         i = i - 1
  164.                         continue
  165.                     continue
  166.                 
  167.             else:
  168.                 self.error('neither < nor & ??')
  169.             match = incomplete.match(rawdata, i)
  170.             if not match:
  171.                 self.handle_data(rawdata[i])
  172.                 i = i + 1
  173.                 continue
  174.             
  175.             j = match.end(0)
  176.             if j == n:
  177.                 break
  178.             
  179.             self.handle_data(rawdata[i:j])
  180.             i = j
  181.         if end and i < n:
  182.             self.handle_data(rawdata[i:n])
  183.             i = n
  184.         
  185.         self.rawdata = rawdata[i:]
  186.  
  187.     _decl_otherchars = '='
  188.     
  189.     def parse_pi(self, i):
  190.         rawdata = self.rawdata
  191.         if rawdata[i:i + 2] != '<?':
  192.             self.error('unexpected call to parse_pi()')
  193.         
  194.         match = piclose.search(rawdata, i + 2)
  195.         if not match:
  196.             return -1
  197.         j = match.start(0)
  198.         self.handle_pi(rawdata[i + 2:j])
  199.         j = match.end(0)
  200.         return j - i
  201.  
  202.     
  203.     def get_starttag_text(self):
  204.         return self._SGMLParser__starttag_text
  205.  
  206.     
  207.     def parse_starttag(self, i):
  208.         self._SGMLParser__starttag_text = None
  209.         start_pos = i
  210.         rawdata = self.rawdata
  211.         if shorttagopen.match(rawdata, i):
  212.             match = shorttag.match(rawdata, i)
  213.             if not match:
  214.                 return -1
  215.             (tag, data) = match.group(1, 2)
  216.             self._SGMLParser__starttag_text = '<%s/' % tag
  217.             tag = tag.lower()
  218.             k = match.end(0)
  219.             self.finish_shorttag(tag, data)
  220.             self._SGMLParser__starttag_text = rawdata[start_pos:match.end(1) + 1]
  221.             return k
  222.         match = endbracket.search(rawdata, i + 1)
  223.         if not match:
  224.             return -1
  225.         j = match.start(0)
  226.         attrs = []
  227.         if rawdata[i:i + 2] == '<>':
  228.             k = j
  229.             tag = self.lasttag
  230.         else:
  231.             match = tagfind.match(rawdata, i + 1)
  232.             if not match:
  233.                 self.error('unexpected call to parse_starttag')
  234.             
  235.             k = match.end(0)
  236.             tag = rawdata[i + 1:k].lower()
  237.             self.lasttag = tag
  238.         while k < j:
  239.             match = attrfind.match(rawdata, k)
  240.             if not match:
  241.                 break
  242.             
  243.             (attrname, rest, attrvalue) = match.group(1, 2, 3)
  244.             if not rest:
  245.                 attrvalue = attrname
  246.             elif "'" == "'":
  247.                 pass
  248.             elif not "'" == attrvalue[-1:]:
  249.                 if '"' == '"':
  250.                     pass
  251.                 elif '"' == attrvalue[-1:]:
  252.                     attrvalue = attrvalue[1:-1]
  253.                 
  254.             attrvalue = self.entity_or_charref.sub(self._convert_ref, attrvalue)
  255.             attrs.append((attrname.lower(), attrvalue))
  256.             k = match.end(0)
  257.             continue
  258.             attrvalue[:1]
  259.         if rawdata[j] == '>':
  260.             j = j + 1
  261.         
  262.         self._SGMLParser__starttag_text = rawdata[start_pos:j]
  263.         self.finish_starttag(tag, attrs)
  264.         return j
  265.  
  266.     
  267.     def _convert_ref(self, match):
  268.         if match.group(2):
  269.             if not self.convert_charref(match.group(2)):
  270.                 pass
  271.             return '&#%s%s' % match.groups()[1:]
  272.         if match.group(3):
  273.             if not self.convert_entityref(match.group(1)):
  274.                 pass
  275.             return '&%s;' % match.group(1)
  276.         return '&%s' % match.group(1)
  277.  
  278.     
  279.     def parse_endtag(self, i):
  280.         rawdata = self.rawdata
  281.         match = endbracket.search(rawdata, i + 1)
  282.         if not match:
  283.             return -1
  284.         j = match.start(0)
  285.         tag = rawdata[i + 2:j].strip().lower()
  286.         if rawdata[j] == '>':
  287.             j = j + 1
  288.         
  289.         self.finish_endtag(tag)
  290.         return j
  291.  
  292.     
  293.     def finish_shorttag(self, tag, data):
  294.         self.finish_starttag(tag, [])
  295.         self.handle_data(data)
  296.         self.finish_endtag(tag)
  297.  
  298.     
  299.     def finish_starttag(self, tag, attrs):
  300.         
  301.         try:
  302.             method = getattr(self, 'start_' + tag)
  303.         except AttributeError:
  304.             
  305.             try:
  306.                 method = getattr(self, 'do_' + tag)
  307.             except AttributeError:
  308.                 self.unknown_starttag(tag, attrs)
  309.                 return -1
  310.  
  311.             self.handle_starttag(tag, method, attrs)
  312.             return 0
  313.  
  314.         self.stack.append(tag)
  315.         self.handle_starttag(tag, method, attrs)
  316.         return 1
  317.  
  318.     
  319.     def finish_endtag(self, tag):
  320.         if not tag:
  321.             found = len(self.stack) - 1
  322.             if found < 0:
  323.                 self.unknown_endtag(tag)
  324.                 return None
  325.         elif tag not in self.stack:
  326.             
  327.             try:
  328.                 method = getattr(self, 'end_' + tag)
  329.             except (AttributeError, ValueError):
  330.                 self.unknown_endtag(tag)
  331.  
  332.             self.report_unbalanced(tag)
  333.             return None
  334.         found = len(self.stack)
  335.         for i in range(found):
  336.             if self.stack[i] == tag:
  337.                 found = i
  338.                 continue
  339.         
  340.         while len(self.stack) > found:
  341.             tag = self.stack[-1]
  342.             
  343.             try:
  344.                 method = getattr(self, 'end_' + tag)
  345.             except AttributeError:
  346.                 method = None
  347.  
  348.             if method:
  349.                 self.handle_endtag(tag, method)
  350.             else:
  351.                 self.unknown_endtag(tag)
  352.             del self.stack[-1]
  353.  
  354.     
  355.     def handle_starttag(self, tag, method, attrs):
  356.         method(attrs)
  357.  
  358.     
  359.     def handle_endtag(self, tag, method):
  360.         method()
  361.  
  362.     
  363.     def report_unbalanced(self, tag):
  364.         if self.verbose:
  365.             print '*** Unbalanced </' + tag + '>'
  366.             print '*** Stack:', self.stack
  367.         
  368.  
  369.     
  370.     def convert_charref(self, name):
  371.         
  372.         try:
  373.             n = int(name)
  374.         except ValueError:
  375.             return None
  376.  
  377.         if n <= n:
  378.             pass
  379.         elif not n <= 255:
  380.             return None
  381.         return self.convert_codepoint(n)
  382.  
  383.     
  384.     def convert_codepoint(self, codepoint):
  385.         return unichr(codepoint)
  386.  
  387.     
  388.     def handle_charref(self, name):
  389.         replacement = self.convert_charref(name)
  390.         if replacement is None:
  391.             self.unknown_charref(name)
  392.         else:
  393.             self.handle_data(replacement)
  394.  
  395.     entitydefs = {
  396.         'lt': '<',
  397.         'gt': '>',
  398.         'amp': '&',
  399.         'quot': '"',
  400.         'apos': "'" }
  401.     
  402.     def convert_entityref(self, name):
  403.         table = self.entitydefs
  404.         if name in table:
  405.             return table[name]
  406.         return None
  407.  
  408.     
  409.     def handle_entityref(self, name):
  410.         replacement = self.convert_entityref(name)
  411.         if replacement is None:
  412.             self.unknown_entityref(name)
  413.         else:
  414.             self.handle_data(self.convert_entityref(name))
  415.  
  416.     
  417.     def handle_data(self, data):
  418.         pass
  419.  
  420.     
  421.     def handle_comment(self, data):
  422.         pass
  423.  
  424.     
  425.     def handle_decl(self, decl):
  426.         pass
  427.  
  428.     
  429.     def handle_pi(self, data):
  430.         pass
  431.  
  432.     
  433.     def unknown_starttag(self, tag, attrs):
  434.         pass
  435.  
  436.     
  437.     def unknown_endtag(self, tag):
  438.         pass
  439.  
  440.     
  441.     def unknown_charref(self, ref):
  442.         pass
  443.  
  444.     
  445.     def unknown_entityref(self, ref):
  446.         pass
  447.  
  448.  
  449.  
  450. class TestSGMLParser(SGMLParser):
  451.     
  452.     def __init__(self, verbose = 0):
  453.         self.testdata = ''
  454.         SGMLParser.__init__(self, verbose)
  455.  
  456.     
  457.     def handle_data(self, data):
  458.         self.testdata = self.testdata + data
  459.         if len(repr(self.testdata)) >= 70:
  460.             self.flush()
  461.         
  462.  
  463.     
  464.     def flush(self):
  465.         data = self.testdata
  466.         if data:
  467.             self.testdata = ''
  468.             print 'data:', repr(data)
  469.         
  470.  
  471.     
  472.     def handle_comment(self, data):
  473.         self.flush()
  474.         r = repr(data)
  475.         if len(r) > 68:
  476.             r = r[:32] + '...' + r[-32:]
  477.         
  478.         print 'comment:', r
  479.  
  480.     
  481.     def unknown_starttag(self, tag, attrs):
  482.         self.flush()
  483.         if not attrs:
  484.             print 'start tag: <' + tag + '>'
  485.         else:
  486.             print 'start tag: <' + tag,
  487.             for name, value in attrs:
  488.                 print name + '=' + '"' + value + '"',
  489.             
  490.             print '>'
  491.  
  492.     
  493.     def unknown_endtag(self, tag):
  494.         self.flush()
  495.         print 'end tag: </' + tag + '>'
  496.  
  497.     
  498.     def unknown_entityref(self, ref):
  499.         self.flush()
  500.         print '*** unknown entity ref: &' + ref + ';'
  501.  
  502.     
  503.     def unknown_charref(self, ref):
  504.         self.flush()
  505.         print '*** unknown char ref: &#' + ref + ';'
  506.  
  507.     
  508.     def unknown_decl(self, data):
  509.         self.flush()
  510.         print '*** unknown decl: [' + data + ']'
  511.  
  512.     
  513.     def close(self):
  514.         SGMLParser.close(self)
  515.         self.flush()
  516.  
  517.  
  518.  
  519. def test(args = None):
  520.     import sys
  521.     if args is None:
  522.         args = sys.argv[1:]
  523.     
  524.     if args and args[0] == '-s':
  525.         args = args[1:]
  526.         klass = SGMLParser
  527.     else:
  528.         klass = TestSGMLParser
  529.     if args:
  530.         file = args[0]
  531.     else:
  532.         file = 'test.html'
  533.     if file == '-':
  534.         f = sys.stdin
  535.     else:
  536.         
  537.         try:
  538.             f = open(file, 'r')
  539.         except IOError:
  540.             msg = None
  541.             print file, ':', msg
  542.             sys.exit(1)
  543.  
  544.     data = f.read()
  545.     if f is not sys.stdin:
  546.         f.close()
  547.     
  548.     x = klass()
  549.     for c in data:
  550.         x.feed(c)
  551.     
  552.     x.close()
  553.  
  554. if __name__ == '__main__':
  555.     test()
  556.  
  557.