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