home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / markupbase.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  9.0 KB  |  389 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Shared support for scanning document type declarations in HTML and XHTML.'''
  5. import re
  6. _declname_match = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*\\s*').match
  7. _declstringlit_match = re.compile('(\\\'[^\\\']*\\\'|"[^"]*")\\s*').match
  8. _commentclose = re.compile('--\\s*>')
  9. _markedsectionclose = re.compile(']\\s*]\\s*>')
  10. _msmarkedsectionclose = re.compile(']\\s*>')
  11. del re
  12.  
  13. class ParserBase:
  14.     '''Parser base class which provides some common support methods used
  15.     by the SGML/HTML and XHTML parsers.'''
  16.     
  17.     def __init__(self):
  18.         if self.__class__ is ParserBase:
  19.             raise RuntimeError('markupbase.ParserBase must be subclassed')
  20.         
  21.  
  22.     
  23.     def error(self, message):
  24.         raise NotImplementedError('subclasses of ParserBase must override error()')
  25.  
  26.     
  27.     def reset(self):
  28.         self.lineno = 1
  29.         self.offset = 0
  30.  
  31.     
  32.     def getpos(self):
  33.         '''Return current line number and offset.'''
  34.         return (self.lineno, self.offset)
  35.  
  36.     
  37.     def updatepos(self, i, j):
  38.         if i >= j:
  39.             return j
  40.         
  41.         rawdata = self.rawdata
  42.         nlines = rawdata.count('\n', i, j)
  43.         if nlines:
  44.             self.lineno = self.lineno + nlines
  45.             pos = rawdata.rindex('\n', i, j)
  46.             self.offset = j - (pos + 1)
  47.         else:
  48.             self.offset = self.offset + j - i
  49.         return j
  50.  
  51.     _decl_otherchars = ''
  52.     
  53.     def parse_declaration(self, i):
  54.         rawdata = self.rawdata
  55.         j = i + 2
  56.         if not rawdata[i:j] == '<!':
  57.             raise AssertionError, 'unexpected call to parse_declaration'
  58.         if rawdata[j:j + 1] in ('-', ''):
  59.             return -1
  60.         
  61.         n = len(rawdata)
  62.         if rawdata[j:j + 1] == '--':
  63.             return self.parse_comment(i)
  64.         elif rawdata[j] == '[':
  65.             return self.parse_marked_section(i)
  66.         else:
  67.             (decltype, j) = self._scan_name(j, i)
  68.         if j < 0:
  69.             return j
  70.         
  71.         if decltype == 'doctype':
  72.             self._decl_otherchars = ''
  73.         
  74.         while j < n:
  75.             c = rawdata[j]
  76.             if c == '>':
  77.                 data = rawdata[i + 2:j]
  78.                 if decltype == 'doctype':
  79.                     self.handle_decl(data)
  80.                 else:
  81.                     self.unknown_decl(data)
  82.                 return j + 1
  83.             
  84.             if c in '"\'':
  85.                 m = _declstringlit_match(rawdata, j)
  86.                 if not m:
  87.                     return -1
  88.                 
  89.                 j = m.end()
  90.             elif c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
  91.                 (name, j) = self._scan_name(j, i)
  92.             elif c in self._decl_otherchars:
  93.                 j = j + 1
  94.             elif c == '[':
  95.                 if decltype == 'doctype':
  96.                     j = self._parse_doctype_subset(j + 1, i)
  97.                 elif decltype in ('attlist', 'linktype', 'link', 'element'):
  98.                     self.error("unsupported '[' char in %s declaration" % decltype)
  99.                 else:
  100.                     self.error("unexpected '[' char in declaration")
  101.             else:
  102.                 self.error('unexpected %r char in declaration' % rawdata[j])
  103.             if j < 0:
  104.                 return j
  105.                 continue
  106.         return -1
  107.  
  108.     
  109.     def parse_marked_section(self, i, report = 1):
  110.         rawdata = self.rawdata
  111.         if not rawdata[i:i + 3] == '<![':
  112.             raise AssertionError, 'unexpected call to parse_marked_section()'
  113.         (sectName, j) = self._scan_name(i + 3, i)
  114.         if j < 0:
  115.             return j
  116.         
  117.         if sectName in ('temp', 'cdata', 'ignore', 'include', 'rcdata'):
  118.             match = _markedsectionclose.search(rawdata, i + 3)
  119.         elif sectName in ('if', 'else', 'endif'):
  120.             match = _msmarkedsectionclose.search(rawdata, i + 3)
  121.         else:
  122.             self.error('unknown status keyword %r in marked section' % rawdata[i + 3:j])
  123.         if not match:
  124.             return -1
  125.         
  126.         if report:
  127.             j = match.start(0)
  128.             self.unknown_decl(rawdata[i + 3:j])
  129.         
  130.         return match.end(0)
  131.  
  132.     
  133.     def parse_comment(self, i, report = 1):
  134.         rawdata = self.rawdata
  135.         if rawdata[i:i + 4] != '<!--':
  136.             self.error('unexpected call to parse_comment()')
  137.         
  138.         match = _commentclose.search(rawdata, i + 4)
  139.         if not match:
  140.             return -1
  141.         
  142.         if report:
  143.             j = match.start(0)
  144.             self.handle_comment(rawdata[i + 4:j])
  145.         
  146.         return match.end(0)
  147.  
  148.     
  149.     def _parse_doctype_subset(self, i, declstartpos):
  150.         rawdata = self.rawdata
  151.         n = len(rawdata)
  152.         j = i
  153.         while j < n:
  154.             c = rawdata[j]
  155.             if c == '<':
  156.                 s = rawdata[j:j + 2]
  157.                 if s == '<':
  158.                     return -1
  159.                 
  160.                 if s != '<!':
  161.                     self.updatepos(declstartpos, j + 1)
  162.                     self.error('unexpected char in internal subset (in %r)' % s)
  163.                 
  164.                 if j + 2 == n:
  165.                     return -1
  166.                 
  167.                 if j + 4 > n:
  168.                     return -1
  169.                 
  170.                 if rawdata[j:j + 4] == '<!--':
  171.                     j = self.parse_comment(j, report = 0)
  172.                     if j < 0:
  173.                         return j
  174.                         continue
  175.                     continue
  176.                 
  177.                 (name, j) = self._scan_name(j + 2, declstartpos)
  178.                 if j == -1:
  179.                     return -1
  180.                 
  181.                 if name not in ('attlist', 'element', 'entity', 'notation'):
  182.                     self.updatepos(declstartpos, j + 2)
  183.                     self.error('unknown declaration %r in internal subset' % name)
  184.                 
  185.                 meth = getattr(self, '_parse_doctype_' + name)
  186.                 j = meth(j, declstartpos)
  187.                 if j < 0:
  188.                     return j
  189.                 
  190.             j < 0
  191.             if c == '%':
  192.                 if j + 1 == n:
  193.                     return -1
  194.                 
  195.                 (s, j) = self._scan_name(j + 1, declstartpos)
  196.                 if j < 0:
  197.                     return j
  198.                 
  199.                 if rawdata[j] == ';':
  200.                     j = j + 1
  201.                 
  202.             rawdata[j] == ';'
  203.             if c == ']':
  204.                 j = j + 1
  205.                 while j < n and rawdata[j].isspace():
  206.                     j = j + 1
  207.                 if j < n:
  208.                     if rawdata[j] == '>':
  209.                         return j
  210.                     
  211.                     self.updatepos(declstartpos, j)
  212.                     self.error('unexpected char after internal subset')
  213.                 else:
  214.                     return -1
  215.             j < n
  216.             if c.isspace():
  217.                 j = j + 1
  218.                 continue
  219.             self.updatepos(declstartpos, j)
  220.             self.error('unexpected char %r in internal subset' % c)
  221.         return -1
  222.  
  223.     
  224.     def _parse_doctype_element(self, i, declstartpos):
  225.         (name, j) = self._scan_name(i, declstartpos)
  226.         if j == -1:
  227.             return -1
  228.         
  229.         rawdata = self.rawdata
  230.         if '>' in rawdata[j:]:
  231.             return rawdata.find('>', j) + 1
  232.         
  233.         return -1
  234.  
  235.     
  236.     def _parse_doctype_attlist(self, i, declstartpos):
  237.         rawdata = self.rawdata
  238.         (name, j) = self._scan_name(i, declstartpos)
  239.         c = rawdata[j:j + 1]
  240.         if c == '':
  241.             return -1
  242.         
  243.         if c == '>':
  244.             return j + 1
  245.         
  246.         while None:
  247.             (name, j) = self._scan_name(j, declstartpos)
  248.             if j < 0:
  249.                 return j
  250.             
  251.             c = rawdata[j:j + 1]
  252.             if c == '':
  253.                 return -1
  254.             
  255.             if c == '(':
  256.                 if ')' in rawdata[j:]:
  257.                     j = rawdata.find(')', j) + 1
  258.                 else:
  259.                     return -1
  260.                 while rawdata[j:j + 1].isspace():
  261.                     j = j + 1
  262.                 if not rawdata[j:]:
  263.                     return -1
  264.                 
  265.             else:
  266.                 (name, j) = self._scan_name(j, declstartpos)
  267.             c = rawdata[j:j + 1]
  268.             if not c:
  269.                 return -1
  270.             
  271.             if c in '\'"':
  272.                 m = _declstringlit_match(rawdata, j)
  273.                 if m:
  274.                     j = m.end()
  275.                 else:
  276.                     return -1
  277.                 c = rawdata[j:j + 1]
  278.                 if not c:
  279.                     return -1
  280.                 
  281.             
  282.             if c == '#':
  283.                 if rawdata[j:] == '#':
  284.                     return -1
  285.                 
  286.                 (name, j) = self._scan_name(j + 1, declstartpos)
  287.                 if j < 0:
  288.                     return j
  289.                 
  290.                 c = rawdata[j:j + 1]
  291.                 if not c:
  292.                     return -1
  293.                 
  294.             
  295.             if c == '>':
  296.                 return j + 1
  297.                 continue
  298.  
  299.     
  300.     def _parse_doctype_notation(self, i, declstartpos):
  301.         (name, j) = self._scan_name(i, declstartpos)
  302.         if j < 0:
  303.             return j
  304.         
  305.         rawdata = self.rawdata
  306.         while None:
  307.             c = rawdata[j:j + 1]
  308.             if not c:
  309.                 return -1
  310.             
  311.             if c == '>':
  312.                 return j + 1
  313.             
  314.             if c in '\'"':
  315.                 m = _declstringlit_match(rawdata, j)
  316.                 if not m:
  317.                     return -1
  318.                 
  319.                 j = m.end()
  320.                 continue
  321.             (name, j) = self._scan_name(j, declstartpos)
  322.             if j < 0:
  323.                 return j
  324.                 continue
  325.  
  326.     
  327.     def _parse_doctype_entity(self, i, declstartpos):
  328.         rawdata = self.rawdata
  329.         if rawdata[i:i + 1] == '%':
  330.             j = i + 1
  331.             while None:
  332.                 c = rawdata[j:j + 1]
  333.                 if not c:
  334.                     return -1
  335.                 
  336.                 if c.isspace():
  337.                     j = j + 1
  338.                     continue
  339.                 break
  340.         else:
  341.             j = i
  342.         (name, j) = self._scan_name(j, declstartpos)
  343.         if j < 0:
  344.             return j
  345.         
  346.         while None:
  347.             c = self.rawdata[j:j + 1]
  348.             if not c:
  349.                 return -1
  350.             
  351.             if c in '\'"':
  352.                 m = _declstringlit_match(rawdata, j)
  353.                 if m:
  354.                     j = m.end()
  355.                 else:
  356.                     return -1
  357.             if c == '>':
  358.                 return j + 1
  359.                 continue
  360.             (name, j) = self._scan_name(j, declstartpos)
  361.             if j < 0:
  362.                 return j
  363.                 continue
  364.  
  365.     
  366.     def _scan_name(self, i, declstartpos):
  367.         rawdata = self.rawdata
  368.         n = len(rawdata)
  369.         if i == n:
  370.             return (None, -1)
  371.         
  372.         m = _declname_match(rawdata, i)
  373.         if m:
  374.             s = m.group()
  375.             name = s.strip()
  376.             if i + len(s) == n:
  377.                 return (None, -1)
  378.             
  379.             return (name.lower(), m.end())
  380.         else:
  381.             self.updatepos(declstartpos, i)
  382.             self.error('expected name token at %r' % rawdata[declstartpos:declstartpos + 20])
  383.  
  384.     
  385.     def unknown_decl(self, data):
  386.         pass
  387.  
  388.  
  389.