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