Lib/sre_compile.py

   1 #
   2 # Secret Labs' Regular Expression Engine
   3 #
   4 # convert template to internal format
   5 #
   6 # Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
   7 #
   8 # See the sre.py file for information on usage and redistribution.
   9 #
  10
  11 import _sre
  12
  13 from sre_constants import *
  14
  15 assert _sre.MAGIC == MAGIC, "SRE module mismatch"
  16
  17 MAXCODE = 65535
  18
  19 def _compile(code, pattern, flags):
  20     # internal: compile a (sub)pattern
  21     emit = code.append
  22     for op, av in pattern:
  23         if op in (LITERAL, NOT_LITERAL):
  24             if flags & SRE_FLAG_IGNORECASE:
  25                 emit(OPCODES[OP_IGNORE[op]])
  26                 emit(_sre.getlower(av, flags))
  27             else:
  28                 emit(OPCODES[op])
  29                 emit(av)
  30         elif op is IN:
  31             if flags & SRE_FLAG_IGNORECASE:
  32                 emit(OPCODES[OP_IGNORE[op]])
  33                 def fixup(literal, flags=flags):
  34                     return _sre.getlower(literal, flags)
  35             else:
  36                 emit(OPCODES[op])
  37                 fixup = lambda x: x
  38             skip = len(code); emit(0)
  39             _compile_charset(av, flags, code, fixup)
  40             code[skip] = len(code) - skip
  41         elif op is ANY:
  42             if flags & SRE_FLAG_DOTALL:
  43                 emit(OPCODES[ANY_ALL])
  44             else:
  45                 emit(OPCODES[ANY])
  46         elif op in (REPEAT, MIN_REPEAT, MAX_REPEAT):
  47             if flags & SRE_FLAG_TEMPLATE:
  48                 raise error, "internal: unsupported template operator"
  49                 emit(OPCODES[REPEAT])
  50                 skip = len(code); emit(0)
  51                 emit(av[0])
  52                 emit(av[1])
  53                 _compile(code, av[2], flags)
  54                 emit(OPCODES[SUCCESS])
  55                 code[skip] = len(code) - skip
  56             elif _simple(av) and op == MAX_REPEAT:
  57                 emit(OPCODES[REPEAT_ONE])
  58                 skip = len(code); emit(0)
  59                 emit(av[0])
  60                 emit(av[1])
  61                 _compile(code, av[2], flags)
  62                 emit(OPCODES[SUCCESS])
  63                 code[skip] = len(code) - skip
  64             else:
  65                 emit(OPCODES[REPEAT])
  66                 skip = len(code); emit(0)
  67                 emit(av[0])
  68                 emit(av[1])
  69                 _compile(code, av[2], flags)
  70                 code[skip] = len(code) - skip
  71                 if op == MAX_REPEAT:
  72                     emit(OPCODES[MAX_UNTIL])
  73                 else:
  74                     emit(OPCODES[MIN_UNTIL])
  75         elif op is SUBPATTERN:
  76             if av[0]:
  77                 emit(OPCODES[MARK])
  78                 emit((av[0]-1)*2)
  79             # _compile_info(code, av[1], flags)
  80             _compile(code, av[1], flags)
  81             if av[0]:
  82                 emit(OPCODES[MARK])
  83                 emit((av[0]-1)*2+1)
  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); emit(0)
  89             if av[0] >= 0:
  90                 emit(0) # look ahead
  91             else:
  92                 lo, hi = av[1].getwidth()
  93                 if lo != hi:
  94                     raise error, "look-behind requires fixed-width pattern"
  95                 emit(lo) # look behind
  96             _compile(code, av[1], flags)
  97             emit(OPCODES[SUCCESS])
  98             code[skip] = len(code) - skip
  99         elif op is CALL:
 100             emit(OPCODES[op])
 101             skip = len(code); emit(0)
 102             _compile(code, av, flags)
 103             emit(OPCODES[SUCCESS])
 104             code[skip] = len(code) - skip
 105         elif op is AT:
 106             emit(OPCODES[op])
 107             if flags & SRE_FLAG_MULTILINE:
 108                 emit(ATCODES[AT_MULTILINE.get(av, av)])
 109             else:
 110                 emit(ATCODES[av])
 111         elif op is BRANCH:
 112             emit(OPCODES[op])
 113             tail = []
 114             for av in av[1]:
 115                 skip = len(code); emit(0)
 116                 # _compile_info(code, av, flags)
 117                 _compile(code, av, flags)
 118                 emit(OPCODES[JUMP])
 119                 tail.append(len(code)); emit(0)
 120                 code[skip] = len(code) - skip
 121             emit(0) # end of branch
 122             for tail in tail:
 123                 code[tail] = len(code) - tail
 124         elif op is CATEGORY:
 125             emit(OPCODES[op])
 126             if flags & SRE_FLAG_LOCALE:
 127                 emit(CHCODES[CH_LOCALE[av]])
 128             elif flags & SRE_FLAG_UNICODE:
 129                 emit(CHCODES[CH_UNICODE[av]])
 130             else:
 131                 emit(CHCODES[av])
 132         elif op is GROUPREF:
 133             if flags & SRE_FLAG_IGNORECASE:
 134                 emit(OPCODES[OP_IGNORE[op]])
 135             else:
 136                 emit(OPCODES[op])
 137             emit(av-1)
 138         else:
 139             raise ValueError, ("unsupported operand type", op)
 140
 141 def _compile_charset(charset, flags, code, fixup=None):
 142     # compile charset subprogram
 143     emit = code.append
 144     if not fixup:
 145         fixup = lambda x: x
 146     for op, av in _optimize_charset(charset, fixup):
 147         emit(OPCODES[op])
 148         if op is NEGATE:
 149             pass
 150         elif op is LITERAL:
 151             emit(fixup(av))
 152         elif op is RANGE:
 153             emit(fixup(av[0]))
 154             emit(fixup(av[1]))
 155         elif op is CHARSET:
 156             code.extend(av)
 157         elif op is CATEGORY:
 158             if flags & SRE_FLAG_LOCALE:
 159                 emit(CHCODES[CH_LOCALE[av]])
 160             elif flags & SRE_FLAG_UNICODE:
 161                 emit(CHCODES[CH_UNICODE[av]])
 162             else:
 163                 emit(CHCODES[av])
 164         else:
 165             raise error, "internal: unsupported set operator"
 166     emit(OPCODES[FAILURE])
 167
 168 def _optimize_charset(charset, fixup):
 169     # internal: optimize character set
 170     out = []
 171     charmap = [0]*256
 172     try:
 173         for op, av in charset:
 174             if op is NEGATE:
 175                 out.append((op, av))
 176             elif op is LITERAL:
 177                 charmap[fixup(av)] = 1
 178             elif op is RANGE:
 179                 for i in range(fixup(av[0]), fixup(av[1])+1):
 180                     charmap[i] = 1
 181             elif op is CATEGORY:
 182                 # XXX: could append to charmap tail
 183                 return charset # cannot compress
 184     except IndexError:
 185         # character set contains unicode characters
 186         return charset
 187     # compress character map
 188     i = p = n = 0
 189     runs = []
 190     for c in charmap:
 191         if c:
 192             if n == 0:
 193                 p = i
 194             n = n + 1
 195         elif n:
 196             runs.append((p, n))
 197             n = 0
 198         i = i + 1
 199     if n:
 200         runs.append((p, n))
 201     if len(runs) <= 2:
 202         # use literal/range
 203         for p, n in runs:
 204             if n == 1:
 205                 out.append((LITERAL, p))
 206             else:
 207                 out.append((RANGE, (p, p+n-1)))
 208         if len(out) < len(charset):
 209             return out
 210     else:
 211         # use bitmap
 212         data = []
 213         m = 1; v = 0
 214         for c in charmap:
 215             if c:
 216                 v = v + m
 217             m = m << 1
 218             if m > MAXCODE:
 219                 data.append(v)
 220                 m = 1; v = 0
 221         out.append((CHARSET, data))
 222         return out
 223     return charset
 224
 225 def _simple(av):
 226     # check if av is a "simple" operator
 227     lo, hi = av[2].getwidth()
 228     if lo == 0 and hi == MAXREPEAT:
 229         raise error, "nothing to repeat"
 230     return lo == hi == 1 and av[2][0][0] != SUBPATTERN
 231
 232 def _compile_info(code, pattern, flags):
 233     # internal: compile an info block.  in the current version,
 234     # this contains min/max pattern width, and an optional literal
 235     # prefix or a character map
 236     lo, hi = pattern.getwidth()
 237     if lo == 0:
 238         return # not worth it
 239     # look for a literal prefix
 240     prefix = []
 241     prefix_skip = 0
 242     charset = [] # not used
 243     if not (flags & SRE_FLAG_IGNORECASE):
 244         # look for literal prefix
 245         for op, av in pattern.data:
 246             if op is LITERAL:
 247                 if len(prefix) == prefix_skip:
 248                     prefix_skip = prefix_skip + 1
 249                 prefix.append(av)
 250             elif op is SUBPATTERN and len(av[1]) == 1:
 251                 op, av = av[1][0]
 252                 if op is LITERAL:
 253                     prefix.append(av)
 254                 else:
 255                     break
 256             else:
 257                 break
 258         # if no prefix, look for charset prefix
 259         if not prefix and pattern.data:
 260             op, av = pattern.data[0]
 261             if op is SUBPATTERN and av[1]:
 262                 op, av = av[1][0]
 263                 if op is LITERAL:
 264                     charset.append((op, av))
 265                 elif op is BRANCH:
 266                     c = []
 267                     for p in av[1]:
 268                         if not p:
 269                             break
 270                         op, av = p[0]
 271                         if op is LITERAL:
 272                             c.append((op, av))
 273                         else:
 274                             break
 275                     else:
 276                         charset = c
 277             elif op is BRANCH:
 278                 c = []
 279                 for p in av[1]:
 280                     if not p:
 281                         break
 282                     op, av = p[0]
 283                     if op is LITERAL:
 284                         c.append((op, av))
 285                     else:
 286                         break
 287                 else:
 288                     charset = c
 289             elif op is IN:
 290                 charset = av
 291 ##     if prefix:
 292 ##         print "*** PREFIX", prefix, prefix_skip
 293 ##     if charset:
 294 ##         print "*** CHARSET", charset
 295     # add an info block
 296     emit = code.append
 297     emit(OPCODES[INFO])
 298     skip = len(code); emit(0)
 299     # literal flag
 300     mask = 0
 301     if prefix:
 302         mask = SRE_INFO_PREFIX
 303         if len(prefix) == prefix_skip == len(pattern.data):
 304             mask = mask + SRE_INFO_LITERAL
 305     elif charset:
 306         mask = mask + SRE_INFO_CHARSET
 307     emit(mask)
 308     # pattern length
 309     if lo < MAXCODE:
 310         emit(lo)
 311     else:
 312         emit(MAXCODE)
 313         prefix = prefix[:MAXCODE]
 314     if hi < MAXCODE:
 315         emit(hi)
 316     else:
 317         emit(0)
 318     # add literal prefix
 319     if prefix:
 320         emit(len(prefix)) # length
 321         emit(prefix_skip) # skip
 322         code.extend(prefix)
 323         # generate overlap table
 324         table = [-1] + ([0]*len(prefix))
 325         for i in range(len(prefix)):
 326             table[i+1] = table[i]+1
 327             while table[i+1] > 0 and prefix[i] != prefix[table[i+1]-1]:
 328                 table[i+1] = table[table[i+1]-1]+1
 329         code.extend(table[1:]) # don't store first entry
 330     elif charset:
 331         _compile_charset(charset, 0, code)
 332     code[skip] = len(code) - skip
 333
 334 STRING_TYPES = [type("")]
 335
 336 try:
 337     STRING_TYPES.append(type(unicode("")))
 338 except NameError:
 339     pass
 340
 341 def _code(p, flags):
 342
 343     flags = p.pattern.flags | flags
 344     code = []
 345
 346     # compile info block
 347     _compile_info(code, p, flags)
 348
 349     # compile the pattern
 350     _compile(code, p.data, flags)
 351
 352     code.append(OPCODES[SUCCESS])
 353
 354     return code
 355
 356 def compile(p, flags=0):
 357     # internal: convert pattern list to internal format
 358
 359     if type(p) in STRING_TYPES:
 360         import sre_parse
 361         pattern = p
 362         p = sre_parse.parse(p, flags)
 363     else:
 364         pattern = None
 365
 366     code = _code(p, flags)
 367
 368     # print code
 369
 370     # XXX: <fl> get rid of this limitation!
 371     assert p.pattern.groups <= 100,\
 372            "sorry, but this version only supports 100 named groups"
 373
 374     # map in either direction
 375     groupindex = p.pattern.groupdict
 376     indexgroup = [None] * p.pattern.groups
 377     for k, i in groupindex.items():
 378         indexgroup[i] = k
 379
 380     return _sre.compile(
 381         pattern, flags, code,
 382         p.pattern.groups-1,
 383         groupindex, indexgroup
 384         )