<s> """<STR_LIT>""" <EOL> import _sre , sys <EOL> from sre_constants import * <EOL> assert _sre . MAGIC == MAGIC , "<STR_LIT>" <EOL> if _sre . CODESIZE == <NUM_LIT:2> : <EOL> MAXCODE = <NUM_LIT> <EOL> else : <EOL> MAXCODE = <NUM_LIT> L <EOL> def _identityfunction ( x ) : <EOL> return x <EOL> def _compile ( code , pattern , flags ) : <EOL> emit = code . append <EOL> _len = len <EOL> LITERAL_CODES = { LITERAL : <NUM_LIT:1> , NOT_LITERAL : <NUM_LIT:1> } <EOL> REPEATING_CODES = { REPEAT : <NUM_LIT:1> , MIN_REPEAT : <NUM_LIT:1> , MAX_REPEAT : <NUM_LIT:1> } <EOL> SUCCESS_CODES = { SUCCESS : <NUM_LIT:1> , FAILURE : <NUM_LIT:1> } <EOL> ASSERT_CODES = { ASSERT : <NUM_LIT:1> , ASSERT_NOT : <NUM_LIT:1> } <EOL> for op , av in pattern : <EOL> if op in LITERAL_CODES : <EOL> if flags & SRE_FLAG_IGNORECASE : <EOL> emit ( OPCODES [ OP_IGNORE [ op ] ] ) <EOL> emit ( _sre . getlower ( av , flags ) ) <EOL> else : <EOL> emit ( OPCODES [ op ] ) <EOL> emit ( av ) <EOL> elif op is IN : <EOL> if flags & SRE_FLAG_IGNORECASE : <EOL> emit ( OPCODES [ OP_IGNORE [ op ] ] ) <EOL> def fixup ( literal , flags = flags ) : <EOL> return _sre . getlower ( literal , flags ) <EOL> else : <EOL> emit ( OPCODES [ op ] ) <EOL> fixup = _identityfunction <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> _compile_charset ( av , flags , code , fixup ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> elif op is ANY : <EOL> if flags & SRE_FLAG_DOTALL : <EOL> emit ( OPCODES [ ANY_ALL ] ) <EOL> else : <EOL> emit ( OPCODES [ ANY ] ) <EOL> elif op in REPEATING_CODES : <EOL> if flags & SRE_FLAG_TEMPLATE : <EOL> raise error , "<STR_LIT>" <EOL> emit ( OPCODES [ REPEAT ] ) <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> emit ( av [ <NUM_LIT:0> ] ) <EOL> emit ( av [ <NUM_LIT:1> ] ) <EOL> _compile ( code , av [ <NUM_LIT:2> ] , flags ) <EOL> emit ( OPCODES [ SUCCESS ] ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> elif _simple ( av ) and op is not REPEAT : <EOL> if op is MAX_REPEAT : <EOL> emit ( OPCODES [ REPEAT_ONE ] ) <EOL> else : <EOL> emit ( OPCODES [ MIN_REPEAT_ONE ] ) <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> emit ( av [ <NUM_LIT:0> ] ) <EOL> emit ( av [ <NUM_LIT:1> ] ) <EOL> _compile ( code , av [ <NUM_LIT:2> ] , flags ) <EOL> emit ( OPCODES [ SUCCESS ] ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> else : <EOL> emit ( OPCODES [ REPEAT ] ) <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> emit ( av [ <NUM_LIT:0> ] ) <EOL> emit ( av [ <NUM_LIT:1> ] ) <EOL> _compile ( code , av [ <NUM_LIT:2> ] , flags ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> if op is MAX_REPEAT : <EOL> emit ( OPCODES [ MAX_UNTIL ] ) <EOL> else : <EOL> emit ( OPCODES [ MIN_UNTIL ] ) <EOL> elif op is SUBPATTERN : <EOL> if av [ <NUM_LIT:0> ] : <EOL> emit ( OPCODES [ MARK ] ) <EOL> emit ( ( av [ <NUM_LIT:0> ] - <NUM_LIT:1> ) * <NUM_LIT:2> ) <EOL> _compile ( code , av [ <NUM_LIT:1> ] , flags ) <EOL> if av [ <NUM_LIT:0> ] : <EOL> emit ( OPCODES [ MARK ] ) <EOL> emit ( ( av [ <NUM_LIT:0> ] - <NUM_LIT:1> ) * <NUM_LIT:2> + <NUM_LIT:1> ) <EOL> elif op in SUCCESS_CODES : <EOL> emit ( OPCODES [ op ] ) <EOL> elif op in ASSERT_CODES : <EOL> emit ( OPCODES [ op ] ) <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> if av [ <NUM_LIT:0> ] >= <NUM_LIT:0> : <EOL> emit ( <NUM_LIT:0> ) <EOL> else : <EOL> lo , hi = av [ <NUM_LIT:1> ] . getwidth ( ) <EOL> if lo != hi : <EOL> raise error , "<STR_LIT>" <EOL> emit ( lo ) <EOL> _compile ( code , av [ <NUM_LIT:1> ] , flags ) <EOL> emit ( OPCODES [ SUCCESS ] ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> elif op is CALL : <EOL> emit ( OPCODES [ op ] ) <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> _compile ( code , av , flags ) <EOL> emit ( OPCODES [ SUCCESS ] ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> elif op is AT : <EOL> emit ( OPCODES [ op ] ) <EOL> if flags & SRE_FLAG_MULTILINE : <EOL> av = AT_MULTILINE . get ( av , av ) <EOL> if flags & SRE_FLAG_LOCALE : <EOL> av = AT_LOCALE . get ( av , av ) <EOL> elif flags & SRE_FLAG_UNICODE : <EOL> av = AT_UNICODE . get ( av , av ) <EOL> emit ( ATCODES [ av ] ) <EOL> elif op is BRANCH : <EOL> emit ( OPCODES [ op ] ) <EOL> tail = [ ] <EOL> tailappend = tail . append <EOL> for av in av [ <NUM_LIT:1> ] : <EOL> skip = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> _compile ( code , av , flags ) <EOL> emit ( OPCODES [ JUMP ] ) <EOL> tailappend ( _len ( code ) ) ; emit ( <NUM_LIT:0> ) <EOL> code [ skip ] = _len ( code ) - skip <EOL> emit ( <NUM_LIT:0> ) <EOL> for tail in tail : <EOL> code [ tail ] = _len ( code ) - tail <EOL> elif op is CATEGORY : <EOL> emit ( OPCODES [ op ] ) <EOL> if flags & SRE_FLAG_LOCALE : <EOL> av = CH_LOCALE [ av ] <EOL> elif flags & SRE_FLAG_UNICODE : <EOL> av = CH_UNICODE [ av ] <EOL> emit ( CHCODES [ av ] ) <EOL> elif op is GROUPREF : <EOL> if flags & SRE_FLAG_IGNORECASE : <EOL> emit ( OPCODES [ OP_IGNORE [ op ] ] ) <EOL> else : <EOL> emit ( OPCODES [ op ] ) <EOL> emit ( av - <NUM_LIT:1> ) <EOL> elif op is GROUPREF_EXISTS : <EOL> emit ( OPCODES [ op ] ) <EOL> emit ( av [ <NUM_LIT:0> ] - <NUM_LIT:1> ) <EOL> skipyes = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> _compile ( code , av [ <NUM_LIT:1> ] , flags ) <EOL> if av [ <NUM_LIT:2> ] : <EOL> emit ( OPCODES [ JUMP ] ) <EOL> skipno = _len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> code [ skipyes ] = _len ( code ) - skipyes + <NUM_LIT:1> <EOL> _compile ( code , av [ <NUM_LIT:2> ] , flags ) <EOL> code [ skipno ] = _len ( code ) - skipno <EOL> else : <EOL> code [ skipyes ] = _len ( code ) - skipyes + <NUM_LIT:1> <EOL> else : <EOL> raise ValueError , ( "<STR_LIT>" , op ) <EOL> def _compile_charset ( charset , flags , code , fixup = None ) : <EOL> emit = code . append <EOL> if fixup is None : <EOL> fixup = _identityfunction <EOL> for op , av in _optimize_charset ( charset , fixup ) : <EOL> emit ( OPCODES [ op ] ) <EOL> if op is NEGATE : <EOL> pass <EOL> elif op is LITERAL : <EOL> emit ( fixup ( av ) ) <EOL> elif op is RANGE : <EOL> emit ( fixup ( av [ <NUM_LIT:0> ] ) ) <EOL> emit ( fixup ( av [ <NUM_LIT:1> ] ) ) <EOL> elif op is CHARSET : <EOL> code . extend ( av ) <EOL> elif op is BIGCHARSET : <EOL> code . extend ( av ) <EOL> elif op is CATEGORY : <EOL> if flags & SRE_FLAG_LOCALE : <EOL> emit ( CHCODES [ CH_LOCALE [ av ] ] ) <EOL> elif flags & SRE_FLAG_UNICODE : <EOL> emit ( CHCODES [ CH_UNICODE [ av ] ] ) <EOL> else : <EOL> emit ( CHCODES [ av ] ) <EOL> else : <EOL> raise error , "<STR_LIT>" <EOL> emit ( OPCODES [ FAILURE ] ) <EOL> def _optimize_charset ( charset , fixup ) : <EOL> out = [ ] <EOL> outappend = out . append <EOL> charmap = [ <NUM_LIT:0> ] * <NUM_LIT> <EOL> try : <EOL> for op , av in charset : <EOL> if op is NEGATE : <EOL> outappend ( ( op , av ) ) <EOL> elif op is LITERAL : <EOL> charmap [ fixup ( av ) ] = <NUM_LIT:1> <EOL> elif op is RANGE : <EOL> for i in range ( fixup ( av [ <NUM_LIT:0> ] ) , fixup ( av [ <NUM_LIT:1> ] ) + <NUM_LIT:1> ) : <EOL> charmap [ i ] = <NUM_LIT:1> <EOL> elif op is CATEGORY : <EOL> return charset <EOL> except IndexError : <EOL> return _optimize_unicode ( charset , fixup ) <EOL> i = p = n = <NUM_LIT:0> <EOL> runs = [ ] <EOL> runsappend = runs . append <EOL> for c in charmap : <EOL> if c : <EOL> if n == <NUM_LIT:0> : <EOL> p = i <EOL> n = n + <NUM_LIT:1> <EOL> elif n : <EOL> runsappend ( ( p , n ) ) <EOL> n = <NUM_LIT:0> <EOL> i = i + <NUM_LIT:1> <EOL> if n : <EOL> runsappend ( ( p , n ) ) <EOL> if len ( runs ) <= <NUM_LIT:2> : <EOL> for p , n in runs : <EOL> if n == <NUM_LIT:1> : <EOL> outappend ( ( LITERAL , p ) ) <EOL> else : <EOL> outappend ( ( RANGE , ( p , p + n - <NUM_LIT:1> ) ) ) <EOL> if len ( out ) < len ( charset ) : <EOL> return out <EOL> else : <EOL> data = _mk_bitmap ( charmap ) <EOL> outappend ( ( CHARSET , data ) ) <EOL> return out <EOL> return charset <EOL> def _mk_bitmap ( bits ) : <EOL> data = [ ] <EOL> dataappend = data . append <EOL> if _sre . CODESIZE == <NUM_LIT:2> : <EOL> start = ( <NUM_LIT:1> , <NUM_LIT:0> ) <EOL> else : <EOL> start = ( <NUM_LIT:1> L , <NUM_LIT:0> L ) <EOL> m , v = start <EOL> for c in bits : <EOL> if c : <EOL> v = v + m <EOL> m = m + m <EOL> if m > MAXCODE : <EOL> dataappend ( v ) <EOL> m , v = start <EOL> return data <EOL> def _optimize_unicode ( charset , fixup ) : <EOL> try : <EOL> import array <EOL> except ImportError : <EOL> return charset <EOL> charmap = [ <NUM_LIT:0> ] * <NUM_LIT> <EOL> negate = <NUM_LIT:0> <EOL> try : <EOL> for op , av in charset : <EOL> if op is NEGATE : <EOL> negate = <NUM_LIT:1> <EOL> elif op is LITERAL : <EOL> charmap [ fixup ( av ) ] = <NUM_LIT:1> <EOL> elif op is RANGE : <EOL> for i in xrange ( fixup ( av [ <NUM_LIT:0> ] ) , fixup ( av [ <NUM_LIT:1> ] ) + <NUM_LIT:1> ) : <EOL> charmap [ i ] = <NUM_LIT:1> <EOL> elif op is CATEGORY : <EOL> return charset <EOL> except IndexError : <EOL> return charset <EOL> if negate : <EOL> if sys . maxunicode != <NUM_LIT> : <EOL> return charset <EOL> for i in xrange ( <NUM_LIT> ) : <EOL> charmap [ i ] = not charmap [ i ] <EOL> comps = { } <EOL> mapping = [ <NUM_LIT:0> ] * <NUM_LIT> <EOL> block = <NUM_LIT:0> <EOL> data = [ ] <EOL> for i in xrange ( <NUM_LIT> ) : <EOL> chunk = tuple ( charmap [ i * <NUM_LIT> : ( i + <NUM_LIT:1> ) * <NUM_LIT> ] ) <EOL> new = comps . setdefault ( chunk , block ) <EOL> mapping [ i ] = new <EOL> if new == block : <EOL> block = block + <NUM_LIT:1> <EOL> data = data + _mk_bitmap ( chunk ) <EOL> header = [ block ] <EOL> if _sre . CODESIZE == <NUM_LIT:2> : <EOL> code = '<STR_LIT:H>' <EOL> else : <EOL> code = '<STR_LIT:I>' <EOL> mapping = array . array ( '<STR_LIT:b>' , mapping ) . tostring ( ) <EOL> mapping = array . array ( code , mapping ) <EOL> assert mapping . itemsize == _sre . CODESIZE <EOL> header = header + mapping . tolist ( ) <EOL> data [ <NUM_LIT:0> : <NUM_LIT:0> ] = header <EOL> return [ ( BIGCHARSET , data ) ] <EOL> def _simple ( av ) : <EOL> lo , hi = av [ <NUM_LIT:2> ] . getwidth ( ) <EOL> if lo == <NUM_LIT:0> and hi == MAXREPEAT : <EOL> raise error , "<STR_LIT>" <EOL> return lo == hi == <NUM_LIT:1> and av [ <NUM_LIT:2> ] [ <NUM_LIT:0> ] [ <NUM_LIT:0> ] != SUBPATTERN <EOL> def _compile_info ( code , pattern , flags ) : <EOL> lo , hi = pattern . getwidth ( ) <EOL> if lo == <NUM_LIT:0> : <EOL> return <EOL> prefix = [ ] <EOL> prefixappend = prefix . append <EOL> prefix_skip = <NUM_LIT:0> <EOL> charset = [ ] <EOL> charsetappend = charset . append <EOL> if not ( flags & SRE_FLAG_IGNORECASE ) : <EOL> for op , av in pattern . data : <EOL> if op is LITERAL : <EOL> if len ( prefix ) == prefix_skip : <EOL> prefix_skip = prefix_skip + <NUM_LIT:1> <EOL> prefixappend ( av ) <EOL> elif op is SUBPATTERN and len ( av [ <NUM_LIT:1> ] ) == <NUM_LIT:1> : <EOL> op , av = av [ <NUM_LIT:1> ] [ <NUM_LIT:0> ] <EOL> if op is LITERAL : <EOL> prefixappend ( av ) <EOL> else : <EOL> break <EOL> else : <EOL> break <EOL> if not prefix and pattern . data : <EOL> op , av = pattern . data [ <NUM_LIT:0> ] <EOL> if op is SUBPATTERN and av [ <NUM_LIT:1> ] : <EOL> op , av = av [ <NUM_LIT:1> ] [ <NUM_LIT:0> ] <EOL> if op is LITERAL : <EOL> charsetappend ( ( op , av ) ) <EOL> elif op is BRANCH : <EOL> c = [ ] <EOL> cappend = c . append <EOL> for p in av [ <NUM_LIT:1> ] : <EOL> if not p : <EOL> break <EOL> op , av = p [ <NUM_LIT:0> ] <EOL> if op is LITERAL : <EOL> cappend ( ( op , av ) ) <EOL> else : <EOL> break <EOL> else : <EOL> charset = c <EOL> elif op is BRANCH : <EOL> c = [ ] <EOL> cappend = c . append <EOL> for p in av [ <NUM_LIT:1> ] : <EOL> if not p : <EOL> break <EOL> op , av = p [ <NUM_LIT:0> ] <EOL> if op is LITERAL : <EOL> cappend ( ( op , av ) ) <EOL> else : <EOL> break <EOL> else : <EOL> charset = c <EOL> elif op is IN : <EOL> charset = av <EOL> emit = code . append <EOL> emit ( OPCODES [ INFO ] ) <EOL> skip = len ( code ) ; emit ( <NUM_LIT:0> ) <EOL> mask = <NUM_LIT:0> <EOL> if prefix : <EOL> mask = SRE_INFO_PREFIX <EOL> if len ( prefix ) == prefix_skip == len ( pattern . data ) : <EOL> mask = mask + SRE_INFO_LITERAL <EOL> elif charset : <EOL> mask = mask + SRE_INFO_CHARSET <EOL> emit ( mask ) <EOL> if lo < MAXCODE : <EOL> emit ( lo ) <EOL> else : <EOL> emit ( MAXCODE ) <EOL> prefix = prefix [ : MAXCODE ] <EOL> if hi < MAXCODE : <EOL> emit ( hi ) <EOL> else : <EOL> emit ( <NUM_LIT:0> ) <EOL> if prefix : <EOL> emit ( len ( prefix ) ) <EOL> emit ( prefix_skip ) <EOL> code . extend ( prefix ) <EOL> table = [ - <NUM_LIT:1> ] + ( [ <NUM_LIT:0> ] * len ( prefix ) ) <EOL> for i in xrange ( len ( prefix ) ) : <EOL> table [ i + <NUM_LIT:1> ] = table [ i ] + <NUM_LIT:1> <EOL> while table [ i + <NUM_LIT:1> ] > <NUM_LIT:0> and prefix [ i ] != prefix [ table [ i + <NUM_LIT:1> ] - <NUM_LIT:1> ] : <EOL> table [ i + <NUM_LIT:1> ] = table [ table [ i + <NUM_LIT:1> ] - <NUM_LIT:1> ] + <NUM_LIT:1> <EOL> code . extend ( table [ <NUM_LIT:1> : ] ) <EOL> elif charset : <EOL> _compile_charset ( charset , flags , code ) <EOL> code [ skip ] = len ( code ) - skip <EOL> try : <EOL> unicode <EOL> except NameError : <EOL> STRING_TYPES = ( type ( "<STR_LIT>" ) , ) <EOL> else : <EOL> STRING_TYPES = ( type ( "<STR_LIT>" ) , type ( unicode ( "<STR_LIT>" ) ) ) <EOL> def isstring ( obj ) : <EOL> for tp in STRING_TYPES : <EOL> if isinstance ( obj , tp ) : <EOL> return <NUM_LIT:1> <EOL> return <NUM_LIT:0> <EOL> def _code ( p , flags ) : <EOL> flags = p . pattern . flags | flags <EOL> code = [ ] <EOL> _compile_info ( code , p , flags ) <EOL> _compile ( code , p . data , flags ) <EOL> code . append ( OPCODES [ SUCCESS ] ) <EOL> return code <EOL> def compile ( p , flags = <NUM_LIT:0> ) : <EOL> if isstring ( p ) : <EOL> import sre_parse <EOL> pattern = p <EOL> p = sre_parse . parse ( p , flags ) <EOL> else : <EOL> pattern = None <EOL> code = _code ( p , flags ) <EOL> if p . pattern . groups > <NUM_LIT:100> : <EOL> raise AssertionError ( <EOL> "<STR_LIT>" <EOL> ) <EOL> groupindex = p . pattern . groupdict <EOL> indexgroup = [ None ] * p . pattern . groups <EOL> for k , i in groupindex . items ( ) : <EOL> indexgroup [ i ] = k <EOL> return _sre . compile ( <EOL> pattern , flags , code , <EOL> p . pattern . groups - <NUM_LIT:1> , <EOL> groupindex , indexgroup <EOL> ) </s>
