]> git.proxmox.com Git - mirror_edk2.git/blame - AppPkg/Applications/Python/Python-2.7.10/Lib/sre_parse.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
AppPkg: Removing ipf which is no longer supported from edk2.
[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Lib / sre_parse.py
CommitLineData
3257aa99
DM		 1#\r
2# Secret Labs' Regular Expression Engine\r
3#\r
4# convert re-style regular expression to sre pattern\r
5#\r
6# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.\r
7#\r
8# See the sre.py file for information on usage and redistribution.\r
9#\r
10\r
11"""Internal support module for sre"""\r
12\r
13# XXX: show string offset and offending character for all errors\r
14\r
15import sys\r
16\r
17from sre_constants import *\r
18\r
19SPECIAL_CHARS = ".\\[{()*+?^$|"\r
20REPEAT_CHARS = "*+?{"\r
21\r
22DIGITS = set("0123456789")\r
23\r
24OCTDIGITS = set("01234567")\r
25HEXDIGITS = set("0123456789abcdefABCDEF")\r
26\r
27WHITESPACE = set(" \t\n\r\v\f")\r
28\r
29ESCAPES = {\r
30 r"\a": (LITERAL, ord("\a")),\r
31 r"\b": (LITERAL, ord("\b")),\r
32 r"\f": (LITERAL, ord("\f")),\r
33 r"\n": (LITERAL, ord("\n")),\r
34 r"\r": (LITERAL, ord("\r")),\r
35 r"\t": (LITERAL, ord("\t")),\r
36 r"\v": (LITERAL, ord("\v")),\r
37 r"\\": (LITERAL, ord("\\"))\r
38}\r
39\r
40CATEGORIES = {\r
41 r"\A": (AT, AT_BEGINNING_STRING), # start of string\r
42 r"\b": (AT, AT_BOUNDARY),\r
43 r"\B": (AT, AT_NON_BOUNDARY),\r
44 r"\d": (IN, [(CATEGORY, CATEGORY_DIGIT)]),\r
45 r"\D": (IN, [(CATEGORY, CATEGORY_NOT_DIGIT)]),\r
46 r"\s": (IN, [(CATEGORY, CATEGORY_SPACE)]),\r
47 r"\S": (IN, [(CATEGORY, CATEGORY_NOT_SPACE)]),\r
48 r"\w": (IN, [(CATEGORY, CATEGORY_WORD)]),\r
49 r"\W": (IN, [(CATEGORY, CATEGORY_NOT_WORD)]),\r
50 r"\Z": (AT, AT_END_STRING), # end of string\r
51}\r
52\r
53FLAGS = {\r
54 # standard flags\r
55 "i": SRE_FLAG_IGNORECASE,\r
56 "L": SRE_FLAG_LOCALE,\r
57 "m": SRE_FLAG_MULTILINE,\r
58 "s": SRE_FLAG_DOTALL,\r
59 "x": SRE_FLAG_VERBOSE,\r
60 # extensions\r
61 "t": SRE_FLAG_TEMPLATE,\r
62 "u": SRE_FLAG_UNICODE,\r
63}\r
64\r
65class Pattern:\r
66 # master pattern object. keeps track of global attributes\r
67 def __init__(self):\r
68 self.flags = 0\r
69 self.open = []\r
70 self.groups = 1\r
71 self.groupdict = {}\r
72 self.lookbehind = 0\r
73\r
74 def opengroup(self, name=None):\r
75 gid = self.groups\r
76 self.groups = gid + 1\r
77 if name is not None:\r
78 ogid = self.groupdict.get(name, None)\r
79 if ogid is not None:\r
80 raise error, ("redefinition of group name %s as group %d; "\r
81 "was group %d" % (repr(name), gid, ogid))\r
82 self.groupdict[name] = gid\r
83 self.open.append(gid)\r
84 return gid\r
85 def closegroup(self, gid):\r
86 self.open.remove(gid)\r
87 def checkgroup(self, gid):\r
88 return gid < self.groups and gid not in self.open\r
89\r
90class SubPattern:\r
91 # a subpattern, in intermediate form\r
92 def __init__(self, pattern, data=None):\r
93 self.pattern = pattern\r
94 if data is None:\r
95 data = []\r
96 self.data = data\r
97 self.width = None\r
98 def dump(self, level=0):\r
99 seqtypes = (tuple, list)\r
100 for op, av in self.data:\r
101 print level*" " + op,\r
102 if op == IN:\r
103 # member sublanguage\r
104 print\r
105 for op, a in av:\r
106 print (level+1)*" " + op, a\r
107 elif op == BRANCH:\r
108 print\r
109 for i, a in enumerate(av[1]):\r
110 if i:\r
111 print level*" " + "or"\r
112 a.dump(level+1)\r
113 elif op == GROUPREF_EXISTS:\r
114 condgroup, item_yes, item_no = av\r
115 print condgroup\r
116 item_yes.dump(level+1)\r
117 if item_no:\r
118 print level*" " + "else"\r
119 item_no.dump(level+1)\r
120 elif isinstance(av, seqtypes):\r
121 nl = 0\r
122 for a in av:\r
123 if isinstance(a, SubPattern):\r
124 if not nl:\r
125 print\r
126 a.dump(level+1)\r
127 nl = 1\r
128 else:\r
129 print a,\r
130 nl = 0\r
131 if not nl:\r
132 print\r
133 else:\r
134 print av\r
135 def __repr__(self):\r
136 return repr(self.data)\r
137 def __len__(self):\r
138 return len(self.data)\r
139 def __delitem__(self, index):\r
140 del self.data[index]\r
141 def __getitem__(self, index):\r
142 if isinstance(index, slice):\r
143 return SubPattern(self.pattern, self.data[index])\r
144 return self.data[index]\r
145 def __setitem__(self, index, code):\r
146 self.data[index] = code\r
147 def insert(self, index, code):\r
148 self.data.insert(index, code)\r
149 def append(self, code):\r
150 self.data.append(code)\r
151 def getwidth(self):\r
152 # determine the width (min, max) for this subpattern\r
153 if self.width:\r
154 return self.width\r
155 lo = hi = 0\r
156 UNITCODES = (ANY, RANGE, IN, LITERAL, NOT_LITERAL, CATEGORY)\r
157 REPEATCODES = (MIN_REPEAT, MAX_REPEAT)\r
158 for op, av in self.data:\r
159 if op is BRANCH:\r
160 i = MAXREPEAT - 1\r
161 j = 0\r
162 for av in av[1]:\r
163 l, h = av.getwidth()\r
164 i = min(i, l)\r
165 j = max(j, h)\r
166 lo = lo + i\r
167 hi = hi + j\r
168 elif op is CALL:\r
169 i, j = av.getwidth()\r
170 lo = lo + i\r
171 hi = hi + j\r
172 elif op is SUBPATTERN:\r
173 i, j = av[1].getwidth()\r
174 lo = lo + i\r
175 hi = hi + j\r
176 elif op in REPEATCODES:\r
177 i, j = av[2].getwidth()\r
178 lo = lo + i * av[0]\r
179 hi = hi + j * av[1]\r
180 elif op in UNITCODES:\r
181 lo = lo + 1\r
182 hi = hi + 1\r
183 elif op == SUCCESS:\r
184 break\r
185 self.width = min(lo, MAXREPEAT - 1), min(hi, MAXREPEAT)\r
186 return self.width\r
187\r
188class Tokenizer:\r
189 def __init__(self, string):\r
190 self.string = string\r
191 self.index = 0\r
192 self.__next()\r
193 def __next(self):\r
194 if self.index >= len(self.string):\r
195 self.next = None\r
196 return\r
197 char = self.string[self.index]\r
198 if char[0] == "\\":\r
199 try:\r
200 c = self.string[self.index + 1]\r
201 except IndexError:\r
202 raise error, "bogus escape (end of line)"\r
203 char = char + c\r
204 self.index = self.index + len(char)\r
205 self.next = char\r
206 def match(self, char, skip=1):\r
207 if char == self.next:\r
208 if skip:\r
209 self.__next()\r
210 return 1\r
211 return 0\r
212 def get(self):\r
213 this = self.next\r
214 self.__next()\r
215 return this\r
216 def tell(self):\r
217 return self.index, self.next\r
218 def seek(self, index):\r
219 self.index, self.next = index\r
220\r
221def isident(char):\r
222 return "a" <= char <= "z" or "A" <= char <= "Z" or char == "_"\r
223\r
224def isdigit(char):\r
225 return "0" <= char <= "9"\r
226\r
227def isname(name):\r
228 # check that group name is a valid string\r
229 if not isident(name[0]):\r
230 return False\r
231 for char in name[1:]:\r
232 if not isident(char) and not isdigit(char):\r
233 return False\r
234 return True\r
235\r
236def _class_escape(source, escape):\r
237 # handle escape code inside character class\r
238 code = ESCAPES.get(escape)\r
239 if code:\r
240 return code\r
241 code = CATEGORIES.get(escape)\r
242 if code and code[0] == IN:\r
243 return code\r
244 try:\r
245 c = escape[1:2]\r
246 if c == "x":\r
247 # hexadecimal escape (exactly two digits)\r
248 while source.next in HEXDIGITS and len(escape) < 4:\r
249 escape = escape + source.get()\r
250 escape = escape[2:]\r
251 if len(escape) != 2:\r
252 raise error, "bogus escape: %s" % repr("\\" + escape)\r
253 return LITERAL, int(escape, 16) & 0xff\r
254 elif c in OCTDIGITS:\r
255 # octal escape (up to three digits)\r
256 while source.next in OCTDIGITS and len(escape) < 4:\r
257 escape = escape + source.get()\r
258 escape = escape[1:]\r
259 return LITERAL, int(escape, 8) & 0xff\r
260 elif c in DIGITS:\r
261 raise error, "bogus escape: %s" % repr(escape)\r
262 if len(escape) == 2:\r
263 return LITERAL, ord(escape[1])\r
264 except ValueError:\r
265 pass\r
266 raise error, "bogus escape: %s" % repr(escape)\r
267\r
268def _escape(source, escape, state):\r
269 # handle escape code in expression\r
270 code = CATEGORIES.get(escape)\r
271 if code:\r
272 return code\r
273 code = ESCAPES.get(escape)\r
274 if code:\r
275 return code\r
276 try:\r
277 c = escape[1:2]\r
278 if c == "x":\r
279 # hexadecimal escape\r
280 while source.next in HEXDIGITS and len(escape) < 4:\r
281 escape = escape + source.get()\r
282 if len(escape) != 4:\r
283 raise ValueError\r
284 return LITERAL, int(escape[2:], 16) & 0xff\r
285 elif c == "0":\r
286 # octal escape\r
287 while source.next in OCTDIGITS and len(escape) < 4:\r
288 escape = escape + source.get()\r
289 return LITERAL, int(escape[1:], 8) & 0xff\r
290 elif c in DIGITS:\r
291 # octal escape *or* decimal group reference (sigh)\r
292 if source.next in DIGITS:\r
293 escape = escape + source.get()\r
294 if (escape[1] in OCTDIGITS and escape[2] in OCTDIGITS and\r
295 source.next in OCTDIGITS):\r
296 # got three octal digits; this is an octal escape\r
297 escape = escape + source.get()\r
298 return LITERAL, int(escape[1:], 8) & 0xff\r
299 # not an octal escape, so this is a group reference\r
300 group = int(escape[1:])\r
301 if group < state.groups:\r
302 if not state.checkgroup(group):\r
303 raise error, "cannot refer to open group"\r
304 if state.lookbehind:\r
305 import warnings\r
306 warnings.warn('group references in lookbehind '\r
307 'assertions are not supported',\r
308 RuntimeWarning)\r
309 return GROUPREF, group\r
310 raise ValueError\r
311 if len(escape) == 2:\r
312 return LITERAL, ord(escape[1])\r
313 except ValueError:\r
314 pass\r
315 raise error, "bogus escape: %s" % repr(escape)\r
316\r
317def _parse_sub(source, state, nested=1):\r
318 # parse an alternation: a|b|c\r
319\r
320 items = []\r
321 itemsappend = items.append\r
322 sourcematch = source.match\r
323 while 1:\r
324 itemsappend(_parse(source, state))\r
325 if sourcematch("|"):\r
326 continue\r
327 if not nested:\r
328 break\r
329 if not source.next or sourcematch(")", 0):\r
330 break\r
331 else:\r
332 raise error, "pattern not properly closed"\r
333\r
334 if len(items) == 1:\r
335 return items[0]\r
336\r
337 subpattern = SubPattern(state)\r
338 subpatternappend = subpattern.append\r
339\r
340 # check if all items share a common prefix\r
341 while 1:\r
342 prefix = None\r
343 for item in items:\r
344 if not item:\r
345 break\r
346 if prefix is None:\r
347 prefix = item[0]\r
348 elif item[0] != prefix:\r
349 break\r
350 else:\r
351 # all subitems start with a common "prefix".\r
352 # move it out of the branch\r
353 for item in items:\r
354 del item[0]\r
355 subpatternappend(prefix)\r
356 continue # check next one\r
357 break\r
358\r
359 # check if the branch can be replaced by a character set\r
360 for item in items:\r
361 if len(item) != 1 or item[0][0] != LITERAL:\r
362 break\r
363 else:\r
364 # we can store this as a character set instead of a\r
365 # branch (the compiler may optimize this even more)\r
366 set = []\r
367 setappend = set.append\r
368 for item in items:\r
369 setappend(item[0])\r
370 subpatternappend((IN, set))\r
371 return subpattern\r
372\r
373 subpattern.append((BRANCH, (None, items)))\r
374 return subpattern\r
375\r
376def _parse_sub_cond(source, state, condgroup):\r
377 item_yes = _parse(source, state)\r
378 if source.match("|"):\r
379 item_no = _parse(source, state)\r
380 if source.match("|"):\r
381 raise error, "conditional backref with more than two branches"\r
382 else:\r
383 item_no = None\r
384 if source.next and not source.match(")", 0):\r
385 raise error, "pattern not properly closed"\r
386 subpattern = SubPattern(state)\r
387 subpattern.append((GROUPREF_EXISTS, (condgroup, item_yes, item_no)))\r
388 return subpattern\r
389\r
390_PATTERNENDERS = set("|)")\r
391_ASSERTCHARS = set("=!<")\r
392_LOOKBEHINDASSERTCHARS = set("=!")\r
393_REPEATCODES = set([MIN_REPEAT, MAX_REPEAT])\r
394\r
395def _parse(source, state):\r
396 # parse a simple pattern\r
397 subpattern = SubPattern(state)\r
398\r
399 # precompute constants into local variables\r
400 subpatternappend = subpattern.append\r
401 sourceget = source.get\r
402 sourcematch = source.match\r
403 _len = len\r
404 PATTERNENDERS = _PATTERNENDERS\r
405 ASSERTCHARS = _ASSERTCHARS\r
406 LOOKBEHINDASSERTCHARS = _LOOKBEHINDASSERTCHARS\r
407 REPEATCODES = _REPEATCODES\r
408\r
409 while 1:\r
410\r
411 if source.next in PATTERNENDERS:\r
412 break # end of subpattern\r
413 this = sourceget()\r
414 if this is None:\r
415 break # end of pattern\r
416\r
417 if state.flags & SRE_FLAG_VERBOSE:\r
418 # skip whitespace and comments\r
419 if this in WHITESPACE:\r
420 continue\r
421 if this == "#":\r
422 while 1:\r
423 this = sourceget()\r
424 if this in (None, "\n"):\r
425 break\r
426 continue\r
427\r
428 if this and this[0] not in SPECIAL_CHARS:\r
429 subpatternappend((LITERAL, ord(this)))\r
430\r
431 elif this == "[":\r
432 # character set\r
433 set = []\r
434 setappend = set.append\r
435## if sourcematch(":"):\r
436## pass # handle character classes\r
437 if sourcematch("^"):\r
438 setappend((NEGATE, None))\r
439 # check remaining characters\r
440 start = set[:]\r
441 while 1:\r
442 this = sourceget()\r
443 if this == "]" and set != start:\r
444 break\r
445 elif this and this[0] == "\\":\r
446 code1 = _class_escape(source, this)\r
447 elif this:\r
448 code1 = LITERAL, ord(this)\r
449 else:\r
450 raise error, "unexpected end of regular expression"\r
451 if sourcematch("-"):\r
452 # potential range\r
453 this = sourceget()\r
454 if this == "]":\r
455 if code1[0] is IN:\r
456 code1 = code1[1][0]\r
457 setappend(code1)\r
458 setappend((LITERAL, ord("-")))\r
459 break\r
460 elif this:\r
461 if this[0] == "\\":\r
462 code2 = _class_escape(source, this)\r
463 else:\r
464 code2 = LITERAL, ord(this)\r
465 if code1[0] != LITERAL or code2[0] != LITERAL:\r
466 raise error, "bad character range"\r
467 lo = code1[1]\r
468 hi = code2[1]\r
469 if hi < lo:\r
470 raise error, "bad character range"\r
471 setappend((RANGE, (lo, hi)))\r
472 else:\r
473 raise error, "unexpected end of regular expression"\r
474 else:\r
475 if code1[0] is IN:\r
476 code1 = code1[1][0]\r
477 setappend(code1)\r
478\r
479 # XXX: <fl> should move set optimization to compiler!\r
480 if _len(set)==1 and set[0][0] is LITERAL:\r
481 subpatternappend(set[0]) # optimization\r
482 elif _len(set)==2 and set[0][0] is NEGATE and set[1][0] is LITERAL:\r
483 subpatternappend((NOT_LITERAL, set[1][1])) # optimization\r
484 else:\r
485 # XXX: <fl> should add charmap optimization here\r
486 subpatternappend((IN, set))\r
487\r
488 elif this and this[0] in REPEAT_CHARS:\r
489 # repeat previous item\r
490 if this == "?":\r
491 min, max = 0, 1\r
492 elif this == "*":\r
493 min, max = 0, MAXREPEAT\r
494\r
495 elif this == "+":\r
496 min, max = 1, MAXREPEAT\r
497 elif this == "{":\r
498 if source.next == "}":\r
499 subpatternappend((LITERAL, ord(this)))\r
500 continue\r
501 here = source.tell()\r
502 min, max = 0, MAXREPEAT\r
503 lo = hi = ""\r
504 while source.next in DIGITS:\r
505 lo = lo + source.get()\r
506 if sourcematch(","):\r
507 while source.next in DIGITS:\r
508 hi = hi + sourceget()\r
509 else:\r
510 hi = lo\r
511 if not sourcematch("}"):\r
512 subpatternappend((LITERAL, ord(this)))\r
513 source.seek(here)\r
514 continue\r
515 if lo:\r
516 min = int(lo)\r
517 if min >= MAXREPEAT:\r
518 raise OverflowError("the repetition number is too large")\r
519 if hi:\r
520 max = int(hi)\r
521 if max >= MAXREPEAT:\r
522 raise OverflowError("the repetition number is too large")\r
523 if max < min:\r
524 raise error("bad repeat interval")\r
525 else:\r
526 raise error, "not supported"\r
527 # figure out which item to repeat\r
528 if subpattern:\r
529 item = subpattern[-1:]\r
530 else:\r
531 item = None\r
532 if not item or (_len(item) == 1 and item[0][0] == AT):\r
533 raise error, "nothing to repeat"\r
534 if item[0][0] in REPEATCODES:\r
535 raise error, "multiple repeat"\r
536 if sourcematch("?"):\r
537 subpattern[-1] = (MIN_REPEAT, (min, max, item))\r
538 else:\r
539 subpattern[-1] = (MAX_REPEAT, (min, max, item))\r
540\r
541 elif this == ".":\r
542 subpatternappend((ANY, None))\r
543\r
544 elif this == "(":\r
545 group = 1\r
546 name = None\r
547 condgroup = None\r
548 if sourcematch("?"):\r
549 group = 0\r
550 # options\r
551 if sourcematch("P"):\r
552 # python extensions\r
553 if sourcematch("<"):\r
554 # named group: skip forward to end of name\r
555 name = ""\r
556 while 1:\r
557 char = sourceget()\r
558 if char is None:\r
559 raise error, "unterminated name"\r
560 if char == ">":\r
561 break\r
562 name = name + char\r
563 group = 1\r
564 if not name:\r
565 raise error("missing group name")\r
566 if not isname(name):\r
567 raise error("bad character in group name %r" %\r
568 name)\r
569 elif sourcematch("="):\r
570 # named backreference\r
571 name = ""\r
572 while 1:\r
573 char = sourceget()\r
574 if char is None:\r
575 raise error, "unterminated name"\r
576 if char == ")":\r
577 break\r
578 name = name + char\r
579 if not name:\r
580 raise error("missing group name")\r
581 if not isname(name):\r
582 raise error("bad character in backref group name "\r
583 "%r" % name)\r
584 gid = state.groupdict.get(name)\r
585 if gid is None:\r
586 msg = "unknown group name: {0!r}".format(name)\r
587 raise error(msg)\r
588 if state.lookbehind:\r
589 import warnings\r
590 warnings.warn('group references in lookbehind '\r
591 'assertions are not supported',\r
592 RuntimeWarning)\r
593 subpatternappend((GROUPREF, gid))\r
594 continue\r
595 else:\r
596 char = sourceget()\r
597 if char is None:\r
598 raise error, "unexpected end of pattern"\r
599 raise error, "unknown specifier: ?P%s" % char\r
600 elif sourcematch(":"):\r
601 # non-capturing group\r
602 group = 2\r
603 elif sourcematch("#"):\r
604 # comment\r
605 while 1:\r
606 if source.next is None or source.next == ")":\r
607 break\r
608 sourceget()\r
609 if not sourcematch(")"):\r
610 raise error, "unbalanced parenthesis"\r
611 continue\r
612 elif source.next in ASSERTCHARS:\r
613 # lookahead assertions\r
614 char = sourceget()\r
615 dir = 1\r
616 if char == "<":\r
617 if source.next not in LOOKBEHINDASSERTCHARS:\r
618 raise error, "syntax error"\r
619 dir = -1 # lookbehind\r
620 char = sourceget()\r
621 state.lookbehind += 1\r
622 p = _parse_sub(source, state)\r
623 if dir < 0:\r
624 state.lookbehind -= 1\r
625 if not sourcematch(")"):\r
626 raise error, "unbalanced parenthesis"\r
627 if char == "=":\r
628 subpatternappend((ASSERT, (dir, p)))\r
629 else:\r
630 subpatternappend((ASSERT_NOT, (dir, p)))\r
631 continue\r
632 elif sourcematch("("):\r
633 # conditional backreference group\r
634 condname = ""\r
635 while 1:\r
636 char = sourceget()\r
637 if char is None:\r
638 raise error, "unterminated name"\r
639 if char == ")":\r
640 break\r
641 condname = condname + char\r
642 group = 2\r
643 if not condname:\r
644 raise error("missing group name")\r
645 if isname(condname):\r
646 condgroup = state.groupdict.get(condname)\r
647 if condgroup is None:\r
648 msg = "unknown group name: {0!r}".format(condname)\r
649 raise error(msg)\r
650 else:\r
651 try:\r
652 condgroup = int(condname)\r
653 except ValueError:\r
654 raise error, "bad character in group name"\r
655 if state.lookbehind:\r
656 import warnings\r
657 warnings.warn('group references in lookbehind '\r
658 'assertions are not supported',\r
659 RuntimeWarning)\r
660 else:\r
661 # flags\r
662 if not source.next in FLAGS:\r
663 raise error, "unexpected end of pattern"\r
664 while source.next in FLAGS:\r
665 state.flags = state.flags | FLAGS[sourceget()]\r
666 if group:\r
667 # parse group contents\r
668 if group == 2:\r
669 # anonymous group\r
670 group = None\r
671 else:\r
672 group = state.opengroup(name)\r
673 if condgroup:\r
674 p = _parse_sub_cond(source, state, condgroup)\r
675 else:\r
676 p = _parse_sub(source, state)\r
677 if not sourcematch(")"):\r
678 raise error, "unbalanced parenthesis"\r
679 if group is not None:\r
680 state.closegroup(group)\r
681 subpatternappend((SUBPATTERN, (group, p)))\r
682 else:\r
683 while 1:\r
684 char = sourceget()\r
685 if char is None:\r
686 raise error, "unexpected end of pattern"\r
687 if char == ")":\r
688 break\r
689 raise error, "unknown extension"\r
690\r
691 elif this == "^":\r
692 subpatternappend((AT, AT_BEGINNING))\r
693\r
694 elif this == "$":\r
695 subpattern.append((AT, AT_END))\r
696\r
697 elif this and this[0] == "\\":\r
698 code = _escape(source, this, state)\r
699 subpatternappend(code)\r
700\r
701 else:\r
702 raise error, "parser error"\r
703\r
704 return subpattern\r
705\r
706def parse(str, flags=0, pattern=None):\r
707 # parse 're' pattern into list of (opcode, argument) tuples\r
708\r
709 source = Tokenizer(str)\r
710\r
711 if pattern is None:\r
712 pattern = Pattern()\r
713 pattern.flags = flags\r
714 pattern.str = str\r
715\r
716 p = _parse_sub(source, pattern, 0)\r
717\r
718 tail = source.get()\r
719 if tail == ")":\r
720 raise error, "unbalanced parenthesis"\r
721 elif tail:\r
722 raise error, "bogus characters at end of regular expression"\r
723\r
724 if flags & SRE_FLAG_DEBUG:\r
725 p.dump()\r
726\r
727 if not (flags & SRE_FLAG_VERBOSE) and p.pattern.flags & SRE_FLAG_VERBOSE:\r
728 # the VERBOSE flag was switched on inside the pattern. to be\r
729 # on the safe side, we'll parse the whole thing again...\r
730 return parse(str, p.pattern.flags)\r
731\r
732 return p\r
733\r
734def parse_template(source, pattern):\r
735 # parse 're' replacement string into list of literals and\r
736 # group references\r
737 s = Tokenizer(source)\r
738 sget = s.get\r
739 p = []\r
740 a = p.append\r
741 def literal(literal, p=p, pappend=a):\r
742 if p and p[-1][0] is LITERAL:\r
743 p[-1] = LITERAL, p[-1][1] + literal\r
744 else:\r
745 pappend((LITERAL, literal))\r
746 sep = source[:0]\r
747 if type(sep) is type(""):\r
748 makechar = chr\r
749 else:\r
750 makechar = unichr\r
751 while 1:\r
752 this = sget()\r
753 if this is None:\r
754 break # end of replacement string\r
755 if this and this[0] == "\\":\r
756 # group\r
757 c = this[1:2]\r
758 if c == "g":\r
759 name = ""\r
760 if s.match("<"):\r
761 while 1:\r
762 char = sget()\r
763 if char is None:\r
764 raise error, "unterminated group name"\r
765 if char == ">":\r
766 break\r
767 name = name + char\r
768 if not name:\r
769 raise error, "missing group name"\r
770 try:\r
771 index = int(name)\r
772 if index < 0:\r
773 raise error, "negative group number"\r
774 except ValueError:\r
775 if not isname(name):\r
776 raise error, "bad character in group name"\r
777 try:\r
778 index = pattern.groupindex[name]\r
779 except KeyError:\r
780 msg = "unknown group name: {0!r}".format(name)\r
781 raise IndexError(msg)\r
782 a((MARK, index))\r
783 elif c == "0":\r
784 if s.next in OCTDIGITS:\r
785 this = this + sget()\r
786 if s.next in OCTDIGITS:\r
787 this = this + sget()\r
788 literal(makechar(int(this[1:], 8) & 0xff))\r
789 elif c in DIGITS:\r
790 isoctal = False\r
791 if s.next in DIGITS:\r
792 this = this + sget()\r
793 if (c in OCTDIGITS and this[2] in OCTDIGITS and\r
794 s.next in OCTDIGITS):\r
795 this = this + sget()\r
796 isoctal = True\r
797 literal(makechar(int(this[1:], 8) & 0xff))\r
798 if not isoctal:\r
799 a((MARK, int(this[1:])))\r
800 else:\r
801 try:\r
802 this = makechar(ESCAPES[this][1])\r
803 except KeyError:\r
804 pass\r
805 literal(this)\r
806 else:\r
807 literal(this)\r
808 # convert template to groups and literals lists\r
809 i = 0\r
810 groups = []\r
811 groupsappend = groups.append\r
812 literals = [None] * len(p)\r
813 for c, s in p:\r
814 if c is MARK:\r
815 groupsappend((i, s))\r
816 # literal[i] is already None\r
817 else:\r
818 literals[i] = s\r
819 i = i + 1\r
820 return groups, literals\r
821\r
822def expand_template(template, match):\r
823 g = match.group\r
824 sep = match.string[:0]\r
825 groups, literals = template\r
826 literals = literals[:]\r
827 try:\r
828 for index, group in groups:\r
829 literals[index] = s = g(group)\r
830 if s is None:\r
831 raise error, "unmatched group"\r
832 except IndexError:\r
833 raise error, "invalid group reference"\r
834 return sep.join(literals)\r
EFI Development Kit II mirror for PVE