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