home *** CD-ROM | disk | FTP | other *** search
/ PC Extra 07 & 08 / pca1507.iso / Software / psp8 / Data1.cab / sre_compile.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-22  |  12.4 KB  |  463 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.2)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if not __debug__ and _sre.MAGIC == MAGIC:
  9.     raise AssertionError, 'SRE module mismatch'
  10. MAXCODE = 65535
  11.  
  12. def _compile(code, pattern, flags):
  13.     emit = code.append
  14.     for op, av in pattern:
  15.         if op in (LITERAL, NOT_LITERAL):
  16.             if flags & SRE_FLAG_IGNORECASE:
  17.                 emit(OPCODES[OP_IGNORE[op]])
  18.                 emit(_sre.getlower(av, flags))
  19.             else:
  20.                 emit(OPCODES[op])
  21.                 emit(av)
  22.         elif op is IN:
  23.             if flags & SRE_FLAG_IGNORECASE:
  24.                 emit(OPCODES[OP_IGNORE[op]])
  25.                 
  26.                 def fixup(literal, flags = flags):
  27.                     return _sre.getlower(literal, flags)
  28.  
  29.             else:
  30.                 emit(OPCODES[op])
  31.                 
  32.                 fixup = lambda x: x
  33.             skip = len(code)
  34.             emit(0)
  35.             _compile_charset(av, flags, code, fixup)
  36.             code[skip] = len(code) - skip
  37.         elif op is ANY:
  38.             if flags & SRE_FLAG_DOTALL:
  39.                 emit(OPCODES[ANY_ALL])
  40.             else:
  41.                 emit(OPCODES[ANY])
  42.         elif op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
  43.             if flags & SRE_FLAG_TEMPLATE:
  44.                 raise error, 'internal: unsupported template operator'
  45.                 emit(OPCODES[REPEAT])
  46.                 skip = len(code)
  47.                 emit(0)
  48.                 emit(av[0])
  49.                 emit(av[1])
  50.                 _compile(code, av[2], flags)
  51.                 emit(OPCODES[SUCCESS])
  52.                 code[skip] = len(code) - skip
  53.             elif _simple(av) and op == MAX_REPEAT:
  54.                 emit(OPCODES[REPEAT_ONE])
  55.                 skip = len(code)
  56.                 emit(0)
  57.                 emit(av[0])
  58.                 emit(av[1])
  59.                 _compile(code, av[2], flags)
  60.                 emit(OPCODES[SUCCESS])
  61.                 code[skip] = len(code) - skip
  62.             else:
  63.                 emit(OPCODES[REPEAT])
  64.                 skip = len(code)
  65.                 emit(0)
  66.                 emit(av[0])
  67.                 emit(av[1])
  68.                 _compile(code, av[2], flags)
  69.                 code[skip] = len(code) - skip
  70.                 if op == MAX_REPEAT:
  71.                     emit(OPCODES[MAX_UNTIL])
  72.                 else:
  73.                     emit(OPCODES[MIN_UNTIL])
  74.         elif op is SUBPATTERN:
  75.             if av[0]:
  76.                 emit(OPCODES[MARK])
  77.                 emit((av[0] - 1) * 2)
  78.             
  79.             _compile(code, av[1], flags)
  80.             if av[0]:
  81.                 emit(OPCODES[MARK])
  82.                 emit((av[0] - 1) * 2 + 1)
  83.             
  84.         elif op in (SUCCESS, FAILURE):
  85.             emit(OPCODES[op])
  86.         elif op in (ASSERT, ASSERT_NOT):
  87.             emit(OPCODES[op])
  88.             skip = len(code)
  89.             emit(0)
  90.             if av[0] >= 0:
  91.                 emit(0)
  92.             else:
  93.                 (lo, hi) = av[1].getwidth()
  94.                 if lo != hi:
  95.                     raise error, 'look-behind requires fixed-width pattern'
  96.                 
  97.                 emit(lo)
  98.             _compile(code, av[1], flags)
  99.             emit(OPCODES[SUCCESS])
  100.             code[skip] = len(code) - skip
  101.         elif op is CALL:
  102.             emit(OPCODES[op])
  103.             skip = len(code)
  104.             emit(0)
  105.             _compile(code, av, flags)
  106.             emit(OPCODES[SUCCESS])
  107.             code[skip] = len(code) - skip
  108.         elif op is AT:
  109.             emit(OPCODES[op])
  110.             if flags & SRE_FLAG_MULTILINE:
  111.                 av = AT_MULTILINE.get(av, av)
  112.             
  113.             if flags & SRE_FLAG_LOCALE:
  114.                 av = AT_LOCALE.get(av, av)
  115.             elif flags & SRE_FLAG_UNICODE:
  116.                 av = AT_UNICODE.get(av, av)
  117.             
  118.             emit(ATCODES[av])
  119.         elif op is BRANCH:
  120.             emit(OPCODES[op])
  121.             tail = []
  122.             for av in av[1]:
  123.                 skip = len(code)
  124.                 emit(0)
  125.                 _compile(code, av, flags)
  126.                 emit(OPCODES[JUMP])
  127.                 tail.append(len(code))
  128.                 emit(0)
  129.                 code[skip] = len(code) - skip
  130.             
  131.             emit(0)
  132.             for tail in tail:
  133.                 code[tail] = len(code) - tail
  134.             
  135.         elif op is CATEGORY:
  136.             emit(OPCODES[op])
  137.             if flags & SRE_FLAG_LOCALE:
  138.                 av = CH_LOCALE[av]
  139.             elif flags & SRE_FLAG_UNICODE:
  140.                 av = CH_UNICODE[av]
  141.             
  142.             emit(CHCODES[av])
  143.         elif op is GROUPREF:
  144.             if flags & SRE_FLAG_IGNORECASE:
  145.                 emit(OPCODES[OP_IGNORE[op]])
  146.             else:
  147.                 emit(OPCODES[op])
  148.             emit(av - 1)
  149.         else:
  150.             raise ValueError, ('unsupported operand type', op)
  151.     
  152.  
  153.  
  154. def _compile_charset(charset, flags, code, fixup = None):
  155.     emit = code.append
  156.     if not fixup:
  157.         
  158.         fixup = lambda x: x
  159.     
  160.     for op, av in _optimize_charset(charset, fixup):
  161.         emit(OPCODES[op])
  162.         if op is NEGATE:
  163.             pass
  164.         elif op is LITERAL:
  165.             emit(fixup(av))
  166.         elif op is RANGE:
  167.             emit(fixup(av[0]))
  168.             emit(fixup(av[1]))
  169.         elif op is CHARSET:
  170.             code.extend(av)
  171.         elif op is BIGCHARSET:
  172.             code.extend(av)
  173.         elif op is CATEGORY:
  174.             if flags & SRE_FLAG_LOCALE:
  175.                 emit(CHCODES[CH_LOCALE[av]])
  176.             elif flags & SRE_FLAG_UNICODE:
  177.                 emit(CHCODES[CH_UNICODE[av]])
  178.             else:
  179.                 emit(CHCODES[av])
  180.         else:
  181.             raise error, 'internal: unsupported set operator'
  182.     
  183.     emit(OPCODES[FAILURE])
  184.  
  185.  
  186. def _optimize_charset(charset, fixup):
  187.     out = []
  188.     charmap = [
  189.         0] * 256
  190.     
  191.     try:
  192.         for op, av in charset:
  193.             if op is NEGATE:
  194.                 out.append((op, av))
  195.             elif op is LITERAL:
  196.                 charmap[fixup(av)] = 1
  197.             elif op is RANGE:
  198.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  199.                     charmap[i] = 1
  200.                 
  201.             elif op is CATEGORY:
  202.                 return charset
  203.             
  204.     except IndexError:
  205.         return _optimize_unicode(charset, fixup)
  206.  
  207.     i = p = n = 0
  208.     runs = []
  209.     for c in charmap:
  210.         if c:
  211.             if n == 0:
  212.                 p = i
  213.             
  214.             n = n + 1
  215.         elif n:
  216.             runs.append((p, n))
  217.             n = 0
  218.         
  219.         i = i + 1
  220.     
  221.     if n:
  222.         runs.append((p, n))
  223.     
  224.     if len(runs) <= 2:
  225.         for p, n in runs:
  226.             if n == 1:
  227.                 out.append((LITERAL, p))
  228.             else:
  229.                 out.append((RANGE, (p, p + n - 1)))
  230.         
  231.         if len(out) < len(charset):
  232.             return out
  233.         
  234.     else:
  235.         data = _mk_bitmap(charmap)
  236.         out.append((CHARSET, data))
  237.         return out
  238.     return charset
  239.  
  240.  
  241. def _mk_bitmap(bits):
  242.     data = []
  243.     m = 1
  244.     v = 0
  245.     for c in bits:
  246.         if c:
  247.             v = v + m
  248.         
  249.         m = m << 1
  250.         if m > MAXCODE:
  251.             data.append(v)
  252.             m = 1
  253.             v = 0
  254.         
  255.     
  256.     return data
  257.  
  258.  
  259. def _optimize_unicode(charset, fixup):
  260.     charmap = [
  261.         0] * 65536
  262.     negate = 0
  263.     for op, av in charset:
  264.         if op is NEGATE:
  265.             negate = 1
  266.         elif op is LITERAL:
  267.             charmap[fixup(av)] = 1
  268.         elif op is RANGE:
  269.             for i in range(fixup(av[0]), fixup(av[1]) + 1):
  270.                 charmap[i] = 1
  271.             
  272.         elif op is CATEGORY:
  273.             return charset
  274.         
  275.     
  276.     if negate:
  277.         for i in range(65536):
  278.             charmap[i] = not charmap[i]
  279.         
  280.     
  281.     comps = { }
  282.     mapping = [
  283.         0] * 256
  284.     block = 0
  285.     data = []
  286.     for i in range(256):
  287.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  288.         new = comps.setdefault(chunk, block)
  289.         mapping[i] = new
  290.         if new == block:
  291.             block += 1
  292.             data += _mk_bitmap(chunk)
  293.         
  294.     
  295.     header = [
  296.         block]
  297.     if not __debug__ and MAXCODE == 65535:
  298.         raise AssertionError
  299.     for i in range(128):
  300.         if sys.byteorder == 'big':
  301.             header.append(256 * mapping[2 * i] + mapping[2 * i + 1])
  302.         else:
  303.             header.append(mapping[2 * i] + 256 * mapping[2 * i + 1])
  304.     
  305.     data[0:0] = header
  306.     return [
  307.         (BIGCHARSET, data)]
  308.  
  309.  
  310. def _simple(av):
  311.     (lo, hi) = av[2].getwidth()
  312.     if lo == 0 and hi == MAXREPEAT:
  313.         raise error, 'nothing to repeat'
  314.     
  315.     if hi == hi:
  316.         pass
  317.     elif hi == 1:
  318.         pass
  319.     return av[2][0][0] != SUBPATTERN
  320.  
  321.  
  322. def _compile_info(code, pattern, flags):
  323.     (lo, hi) = pattern.getwidth()
  324.     if lo == 0:
  325.         return None
  326.     
  327.     prefix = []
  328.     prefix_skip = 0
  329.     charset = []
  330.     if not (flags & SRE_FLAG_IGNORECASE):
  331.         for op, av in pattern.data:
  332.             if op is LITERAL:
  333.                 if len(prefix) == prefix_skip:
  334.                     prefix_skip = prefix_skip + 1
  335.                 
  336.                 prefix.append(av)
  337.             elif op is SUBPATTERN and len(av[1]) == 1:
  338.                 (op, av) = av[1][0]
  339.                 if op is LITERAL:
  340.                     prefix.append(av)
  341.                 else:
  342.                     break
  343.             else:
  344.                 break
  345.         
  346.         if not prefix and pattern.data:
  347.             (op, av) = pattern.data[0]
  348.             if op is SUBPATTERN and av[1]:
  349.                 (op, av) = av[1][0]
  350.                 if op is LITERAL:
  351.                     charset.append((op, av))
  352.                 elif op is BRANCH:
  353.                     c = []
  354.                     for p in av[1]:
  355.                         if not p:
  356.                             break
  357.                         
  358.                         (op, av) = p[0]
  359.                         if op is LITERAL:
  360.                             c.append((op, av))
  361.                         else:
  362.                             break
  363.                     else:
  364.                         charset = c
  365.                 
  366.             elif op is BRANCH:
  367.                 c = []
  368.                 for p in av[1]:
  369.                     if not p:
  370.                         break
  371.                     
  372.                     (op, av) = p[0]
  373.                     if op is LITERAL:
  374.                         c.append((op, av))
  375.                     else:
  376.                         break
  377.                 else:
  378.                     charset = c
  379.             elif op is IN:
  380.                 charset = av
  381.             
  382.         
  383.     
  384.     emit = code.append
  385.     emit(OPCODES[INFO])
  386.     skip = len(code)
  387.     emit(0)
  388.     mask = 0
  389.     if prefix:
  390.         mask = SRE_INFO_PREFIX
  391.         if prefix_skip == prefix_skip:
  392.             pass
  393.         elif prefix_skip == len(pattern.data):
  394.             mask = mask + SRE_INFO_LITERAL
  395.         
  396.     elif charset:
  397.         mask = mask + SRE_INFO_CHARSET
  398.     
  399.     emit(mask)
  400.     if lo < MAXCODE:
  401.         emit(lo)
  402.     else:
  403.         emit(MAXCODE)
  404.         prefix = prefix[:MAXCODE]
  405.     if hi < MAXCODE:
  406.         emit(hi)
  407.     else:
  408.         emit(0)
  409.     if prefix:
  410.         emit(len(prefix))
  411.         emit(prefix_skip)
  412.         code.extend(prefix)
  413.         table = [
  414.             -1] + [
  415.             0] * len(prefix)
  416.         for i in range(len(prefix)):
  417.             table[i + 1] = table[i] + 1
  418.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  419.                 table[i + 1] = table[table[i + 1] - 1] + 1
  420.         
  421.         code.extend(table[1:])
  422.     elif charset:
  423.         _compile_charset(charset, 0, code)
  424.     
  425.     code[skip] = len(code) - skip
  426.  
  427. STRING_TYPES = [
  428.     type('')]
  429.  
  430. try:
  431.     STRING_TYPES.append(type(unicode('')))
  432. except NameError:
  433.     pass
  434.  
  435.  
  436. def _code(p, flags):
  437.     flags = p.pattern.flags | flags
  438.     code = []
  439.     _compile_info(code, p, flags)
  440.     _compile(code, p.data, flags)
  441.     code.append(OPCODES[SUCCESS])
  442.     return code
  443.  
  444.  
  445. def compile(p, flags = 0):
  446.     if type(p) in STRING_TYPES:
  447.         import sre_parse
  448.         pattern = p
  449.         p = sre_parse.parse(p, flags)
  450.     else:
  451.         pattern = None
  452.     code = _code(p, flags)
  453.     if not __debug__ and p.pattern.groups <= 100:
  454.         raise AssertionError, 'sorry, but this version only supports 100 named groups'
  455.     groupindex = p.pattern.groupdict
  456.     indexgroup = [
  457.         None] * p.pattern.groups
  458.     for k, i in groupindex.items():
  459.         indexgroup[i] = k
  460.     
  461.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  462.  
  463.