Removed the Requirement to Install Python and NodeJS (Now Bundled with Borealis)
This commit is contained in:
428
Dependencies/Python/Lib/re/__init__.py
vendored
Normal file
428
Dependencies/Python/Lib/re/__init__.py
vendored
Normal file
@ -0,0 +1,428 @@
|
||||
#
|
||||
# Secret Labs' Regular Expression Engine
|
||||
#
|
||||
# re-compatible interface for the sre matching engine
|
||||
#
|
||||
# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
|
||||
#
|
||||
# This version of the SRE library can be redistributed under CNRI's
|
||||
# Python 1.6 license. For any other use, please contact Secret Labs
|
||||
# AB (info@pythonware.com).
|
||||
#
|
||||
# Portions of this engine have been developed in cooperation with
|
||||
# CNRI. Hewlett-Packard provided funding for 1.6 integration and
|
||||
# other compatibility work.
|
||||
#
|
||||
|
||||
r"""Support for regular expressions (RE).
|
||||
|
||||
This module provides regular expression matching operations similar to
|
||||
those found in Perl. It supports both 8-bit and Unicode strings; both
|
||||
the pattern and the strings being processed can contain null bytes and
|
||||
characters outside the US ASCII range.
|
||||
|
||||
Regular expressions can contain both special and ordinary characters.
|
||||
Most ordinary characters, like "A", "a", or "0", are the simplest
|
||||
regular expressions; they simply match themselves. You can
|
||||
concatenate ordinary characters, so last matches the string 'last'.
|
||||
|
||||
The special characters are:
|
||||
"." Matches any character except a newline.
|
||||
"^" Matches the start of the string.
|
||||
"$" Matches the end of the string or just before the newline at
|
||||
the end of the string.
|
||||
"*" Matches 0 or more (greedy) repetitions of the preceding RE.
|
||||
Greedy means that it will match as many repetitions as possible.
|
||||
"+" Matches 1 or more (greedy) repetitions of the preceding RE.
|
||||
"?" Matches 0 or 1 (greedy) of the preceding RE.
|
||||
*?,+?,?? Non-greedy versions of the previous three special characters.
|
||||
{m,n} Matches from m to n repetitions of the preceding RE.
|
||||
{m,n}? Non-greedy version of the above.
|
||||
"\\" Either escapes special characters or signals a special sequence.
|
||||
[] Indicates a set of characters.
|
||||
A "^" as the first character indicates a complementing set.
|
||||
"|" A|B, creates an RE that will match either A or B.
|
||||
(...) Matches the RE inside the parentheses.
|
||||
The contents can be retrieved or matched later in the string.
|
||||
(?aiLmsux) The letters set the corresponding flags defined below.
|
||||
(?:...) Non-grouping version of regular parentheses.
|
||||
(?P<name>...) The substring matched by the group is accessible by name.
|
||||
(?P=name) Matches the text matched earlier by the group named name.
|
||||
(?#...) A comment; ignored.
|
||||
(?=...) Matches if ... matches next, but doesn't consume the string.
|
||||
(?!...) Matches if ... doesn't match next.
|
||||
(?<=...) Matches if preceded by ... (must be fixed length).
|
||||
(?<!...) Matches if not preceded by ... (must be fixed length).
|
||||
(?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
|
||||
the (optional) no pattern otherwise.
|
||||
|
||||
The special sequences consist of "\\" and a character from the list
|
||||
below. If the ordinary character is not on the list, then the
|
||||
resulting RE will match the second character.
|
||||
\number Matches the contents of the group of the same number.
|
||||
\A Matches only at the start of the string.
|
||||
\Z Matches only at the end of the string.
|
||||
\b Matches the empty string, but only at the start or end of a word.
|
||||
\B Matches the empty string, but not at the start or end of a word.
|
||||
\d Matches any decimal digit; equivalent to the set [0-9] in
|
||||
bytes patterns or string patterns with the ASCII flag.
|
||||
In string patterns without the ASCII flag, it will match the whole
|
||||
range of Unicode digits.
|
||||
\D Matches any non-digit character; equivalent to [^\d].
|
||||
\s Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
|
||||
bytes patterns or string patterns with the ASCII flag.
|
||||
In string patterns without the ASCII flag, it will match the whole
|
||||
range of Unicode whitespace characters.
|
||||
\S Matches any non-whitespace character; equivalent to [^\s].
|
||||
\w Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
|
||||
in bytes patterns or string patterns with the ASCII flag.
|
||||
In string patterns without the ASCII flag, it will match the
|
||||
range of Unicode alphanumeric characters (letters plus digits
|
||||
plus underscore).
|
||||
With LOCALE, it will match the set [0-9_] plus characters defined
|
||||
as letters for the current locale.
|
||||
\W Matches the complement of \w.
|
||||
\\ Matches a literal backslash.
|
||||
|
||||
This module exports the following functions:
|
||||
match Match a regular expression pattern to the beginning of a string.
|
||||
fullmatch Match a regular expression pattern to all of a string.
|
||||
search Search a string for the presence of a pattern.
|
||||
sub Substitute occurrences of a pattern found in a string.
|
||||
subn Same as sub, but also return the number of substitutions made.
|
||||
split Split a string by the occurrences of a pattern.
|
||||
findall Find all occurrences of a pattern in a string.
|
||||
finditer Return an iterator yielding a Match object for each match.
|
||||
compile Compile a pattern into a Pattern object.
|
||||
purge Clear the regular expression cache.
|
||||
escape Backslash all non-alphanumerics in a string.
|
||||
|
||||
Each function other than purge and escape can take an optional 'flags' argument
|
||||
consisting of one or more of the following module constants, joined by "|".
|
||||
A, L, and U are mutually exclusive.
|
||||
A ASCII For string patterns, make \w, \W, \b, \B, \d, \D
|
||||
match the corresponding ASCII character categories
|
||||
(rather than the whole Unicode categories, which is the
|
||||
default).
|
||||
For bytes patterns, this flag is the only available
|
||||
behaviour and needn't be specified.
|
||||
I IGNORECASE Perform case-insensitive matching.
|
||||
L LOCALE Make \w, \W, \b, \B, dependent on the current locale.
|
||||
M MULTILINE "^" matches the beginning of lines (after a newline)
|
||||
as well as the string.
|
||||
"$" matches the end of lines (before a newline) as well
|
||||
as the end of the string.
|
||||
S DOTALL "." matches any character at all, including the newline.
|
||||
X VERBOSE Ignore whitespace and comments for nicer looking RE's.
|
||||
U UNICODE For compatibility only. Ignored for string patterns (it
|
||||
is the default), and forbidden for bytes patterns.
|
||||
|
||||
This module also defines exception 'PatternError', aliased to 'error' for
|
||||
backward compatibility.
|
||||
|
||||
"""
|
||||
|
||||
import enum
|
||||
from . import _compiler, _parser
|
||||
import functools
|
||||
import _sre
|
||||
|
||||
|
||||
# public symbols
|
||||
__all__ = [
|
||||
"match", "fullmatch", "search", "sub", "subn", "split",
|
||||
"findall", "finditer", "compile", "purge", "escape",
|
||||
"error", "Pattern", "Match", "A", "I", "L", "M", "S", "X", "U",
|
||||
"ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
|
||||
"UNICODE", "NOFLAG", "RegexFlag", "PatternError"
|
||||
]
|
||||
|
||||
__version__ = "2.2.1"
|
||||
|
||||
@enum.global_enum
|
||||
@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
|
||||
class RegexFlag:
|
||||
NOFLAG = 0
|
||||
ASCII = A = _compiler.SRE_FLAG_ASCII # assume ascii "locale"
|
||||
IGNORECASE = I = _compiler.SRE_FLAG_IGNORECASE # ignore case
|
||||
LOCALE = L = _compiler.SRE_FLAG_LOCALE # assume current 8-bit locale
|
||||
UNICODE = U = _compiler.SRE_FLAG_UNICODE # assume unicode "locale"
|
||||
MULTILINE = M = _compiler.SRE_FLAG_MULTILINE # make anchors look for newline
|
||||
DOTALL = S = _compiler.SRE_FLAG_DOTALL # make dot match newline
|
||||
VERBOSE = X = _compiler.SRE_FLAG_VERBOSE # ignore whitespace and comments
|
||||
# sre extensions (experimental, don't rely on these)
|
||||
DEBUG = _compiler.SRE_FLAG_DEBUG # dump pattern after compilation
|
||||
__str__ = object.__str__
|
||||
_numeric_repr_ = hex
|
||||
|
||||
# sre exception
|
||||
PatternError = error = _compiler.PatternError
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# public interface
|
||||
|
||||
def match(pattern, string, flags=0):
|
||||
"""Try to apply the pattern at the start of the string, returning
|
||||
a Match object, or None if no match was found."""
|
||||
return _compile(pattern, flags).match(string)
|
||||
|
||||
def fullmatch(pattern, string, flags=0):
|
||||
"""Try to apply the pattern to all of the string, returning
|
||||
a Match object, or None if no match was found."""
|
||||
return _compile(pattern, flags).fullmatch(string)
|
||||
|
||||
def search(pattern, string, flags=0):
|
||||
"""Scan through string looking for a match to the pattern, returning
|
||||
a Match object, or None if no match was found."""
|
||||
return _compile(pattern, flags).search(string)
|
||||
|
||||
class _ZeroSentinel(int):
|
||||
pass
|
||||
_zero_sentinel = _ZeroSentinel()
|
||||
|
||||
def sub(pattern, repl, string, *args, count=_zero_sentinel, flags=_zero_sentinel):
|
||||
"""Return the string obtained by replacing the leftmost
|
||||
non-overlapping occurrences of the pattern in string by the
|
||||
replacement repl. repl can be either a string or a callable;
|
||||
if a string, backslash escapes in it are processed. If it is
|
||||
a callable, it's passed the Match object and must return
|
||||
a replacement string to be used."""
|
||||
if args:
|
||||
if count is not _zero_sentinel:
|
||||
raise TypeError("sub() got multiple values for argument 'count'")
|
||||
count, *args = args
|
||||
if args:
|
||||
if flags is not _zero_sentinel:
|
||||
raise TypeError("sub() got multiple values for argument 'flags'")
|
||||
flags, *args = args
|
||||
if args:
|
||||
raise TypeError("sub() takes from 3 to 5 positional arguments "
|
||||
"but %d were given" % (5 + len(args)))
|
||||
|
||||
import warnings
|
||||
warnings.warn(
|
||||
"'count' is passed as positional argument",
|
||||
DeprecationWarning, stacklevel=2
|
||||
)
|
||||
|
||||
return _compile(pattern, flags).sub(repl, string, count)
|
||||
sub.__text_signature__ = '(pattern, repl, string, count=0, flags=0)'
|
||||
|
||||
def subn(pattern, repl, string, *args, count=_zero_sentinel, flags=_zero_sentinel):
|
||||
"""Return a 2-tuple containing (new_string, number).
|
||||
new_string is the string obtained by replacing the leftmost
|
||||
non-overlapping occurrences of the pattern in the source
|
||||
string by the replacement repl. number is the number of
|
||||
substitutions that were made. repl can be either a string or a
|
||||
callable; if a string, backslash escapes in it are processed.
|
||||
If it is a callable, it's passed the Match object and must
|
||||
return a replacement string to be used."""
|
||||
if args:
|
||||
if count is not _zero_sentinel:
|
||||
raise TypeError("subn() got multiple values for argument 'count'")
|
||||
count, *args = args
|
||||
if args:
|
||||
if flags is not _zero_sentinel:
|
||||
raise TypeError("subn() got multiple values for argument 'flags'")
|
||||
flags, *args = args
|
||||
if args:
|
||||
raise TypeError("subn() takes from 3 to 5 positional arguments "
|
||||
"but %d were given" % (5 + len(args)))
|
||||
|
||||
import warnings
|
||||
warnings.warn(
|
||||
"'count' is passed as positional argument",
|
||||
DeprecationWarning, stacklevel=2
|
||||
)
|
||||
|
||||
return _compile(pattern, flags).subn(repl, string, count)
|
||||
subn.__text_signature__ = '(pattern, repl, string, count=0, flags=0)'
|
||||
|
||||
def split(pattern, string, *args, maxsplit=_zero_sentinel, flags=_zero_sentinel):
|
||||
"""Split the source string by the occurrences of the pattern,
|
||||
returning a list containing the resulting substrings. If
|
||||
capturing parentheses are used in pattern, then the text of all
|
||||
groups in the pattern are also returned as part of the resulting
|
||||
list. If maxsplit is nonzero, at most maxsplit splits occur,
|
||||
and the remainder of the string is returned as the final element
|
||||
of the list."""
|
||||
if args:
|
||||
if maxsplit is not _zero_sentinel:
|
||||
raise TypeError("split() got multiple values for argument 'maxsplit'")
|
||||
maxsplit, *args = args
|
||||
if args:
|
||||
if flags is not _zero_sentinel:
|
||||
raise TypeError("split() got multiple values for argument 'flags'")
|
||||
flags, *args = args
|
||||
if args:
|
||||
raise TypeError("split() takes from 2 to 4 positional arguments "
|
||||
"but %d were given" % (4 + len(args)))
|
||||
|
||||
import warnings
|
||||
warnings.warn(
|
||||
"'maxsplit' is passed as positional argument",
|
||||
DeprecationWarning, stacklevel=2
|
||||
)
|
||||
|
||||
return _compile(pattern, flags).split(string, maxsplit)
|
||||
split.__text_signature__ = '(pattern, string, maxsplit=0, flags=0)'
|
||||
|
||||
def findall(pattern, string, flags=0):
|
||||
"""Return a list of all non-overlapping matches in the string.
|
||||
|
||||
If one or more capturing groups are present in the pattern, return
|
||||
a list of groups; this will be a list of tuples if the pattern
|
||||
has more than one group.
|
||||
|
||||
Empty matches are included in the result."""
|
||||
return _compile(pattern, flags).findall(string)
|
||||
|
||||
def finditer(pattern, string, flags=0):
|
||||
"""Return an iterator over all non-overlapping matches in the
|
||||
string. For each match, the iterator returns a Match object.
|
||||
|
||||
Empty matches are included in the result."""
|
||||
return _compile(pattern, flags).finditer(string)
|
||||
|
||||
def compile(pattern, flags=0):
|
||||
"Compile a regular expression pattern, returning a Pattern object."
|
||||
return _compile(pattern, flags)
|
||||
|
||||
def purge():
|
||||
"Clear the regular expression caches"
|
||||
_cache.clear()
|
||||
_cache2.clear()
|
||||
_compile_template.cache_clear()
|
||||
|
||||
|
||||
# SPECIAL_CHARS
|
||||
# closing ')', '}' and ']'
|
||||
# '-' (a range in character set)
|
||||
# '&', '~', (extended character set operations)
|
||||
# '#' (comment) and WHITESPACE (ignored) in verbose mode
|
||||
_special_chars_map = {i: '\\' + chr(i) for i in b'()[]{}?*+-|^$\\.&~# \t\n\r\v\f'}
|
||||
|
||||
def escape(pattern):
|
||||
"""
|
||||
Escape special characters in a string.
|
||||
"""
|
||||
if isinstance(pattern, str):
|
||||
return pattern.translate(_special_chars_map)
|
||||
else:
|
||||
pattern = str(pattern, 'latin1')
|
||||
return pattern.translate(_special_chars_map).encode('latin1')
|
||||
|
||||
Pattern = type(_compiler.compile('', 0))
|
||||
Match = type(_compiler.compile('', 0).match(''))
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# internals
|
||||
|
||||
# Use the fact that dict keeps the insertion order.
|
||||
# _cache2 uses the simple FIFO policy which has better latency.
|
||||
# _cache uses the LRU policy which has better hit rate.
|
||||
_cache = {} # LRU
|
||||
_cache2 = {} # FIFO
|
||||
_MAXCACHE = 512
|
||||
_MAXCACHE2 = 256
|
||||
assert _MAXCACHE2 < _MAXCACHE
|
||||
|
||||
def _compile(pattern, flags):
|
||||
# internal: compile pattern
|
||||
if isinstance(flags, RegexFlag):
|
||||
flags = flags.value
|
||||
try:
|
||||
return _cache2[type(pattern), pattern, flags]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
key = (type(pattern), pattern, flags)
|
||||
# Item in _cache should be moved to the end if found.
|
||||
p = _cache.pop(key, None)
|
||||
if p is None:
|
||||
if isinstance(pattern, Pattern):
|
||||
if flags:
|
||||
raise ValueError(
|
||||
"cannot process flags argument with a compiled pattern")
|
||||
return pattern
|
||||
if not _compiler.isstring(pattern):
|
||||
raise TypeError("first argument must be string or compiled pattern")
|
||||
p = _compiler.compile(pattern, flags)
|
||||
if flags & DEBUG:
|
||||
return p
|
||||
if len(_cache) >= _MAXCACHE:
|
||||
# Drop the least recently used item.
|
||||
# next(iter(_cache)) is known to have linear amortized time,
|
||||
# but it is used here to avoid a dependency from using OrderedDict.
|
||||
# For the small _MAXCACHE value it doesn't make much of a difference.
|
||||
try:
|
||||
del _cache[next(iter(_cache))]
|
||||
except (StopIteration, RuntimeError, KeyError):
|
||||
pass
|
||||
# Append to the end.
|
||||
_cache[key] = p
|
||||
|
||||
if len(_cache2) >= _MAXCACHE2:
|
||||
# Drop the oldest item.
|
||||
try:
|
||||
del _cache2[next(iter(_cache2))]
|
||||
except (StopIteration, RuntimeError, KeyError):
|
||||
pass
|
||||
_cache2[key] = p
|
||||
return p
|
||||
|
||||
@functools.lru_cache(_MAXCACHE)
|
||||
def _compile_template(pattern, repl):
|
||||
# internal: compile replacement pattern
|
||||
return _sre.template(pattern, _parser.parse_template(repl, pattern))
|
||||
|
||||
# register myself for pickling
|
||||
|
||||
import copyreg
|
||||
|
||||
def _pickle(p):
|
||||
return _compile, (p.pattern, p.flags)
|
||||
|
||||
copyreg.pickle(Pattern, _pickle, _compile)
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# experimental stuff (see python-dev discussions for details)
|
||||
|
||||
class Scanner:
|
||||
def __init__(self, lexicon, flags=0):
|
||||
from ._constants import BRANCH, SUBPATTERN
|
||||
if isinstance(flags, RegexFlag):
|
||||
flags = flags.value
|
||||
self.lexicon = lexicon
|
||||
# combine phrases into a compound pattern
|
||||
p = []
|
||||
s = _parser.State()
|
||||
s.flags = flags
|
||||
for phrase, action in lexicon:
|
||||
gid = s.opengroup()
|
||||
p.append(_parser.SubPattern(s, [
|
||||
(SUBPATTERN, (gid, 0, 0, _parser.parse(phrase, flags))),
|
||||
]))
|
||||
s.closegroup(gid, p[-1])
|
||||
p = _parser.SubPattern(s, [(BRANCH, (None, p))])
|
||||
self.scanner = _compiler.compile(p)
|
||||
def scan(self, string):
|
||||
result = []
|
||||
append = result.append
|
||||
match = self.scanner.scanner(string).match
|
||||
i = 0
|
||||
while True:
|
||||
m = match()
|
||||
if not m:
|
||||
break
|
||||
j = m.end()
|
||||
if i == j:
|
||||
break
|
||||
action = self.lexicon[m.lastindex-1][1]
|
||||
if callable(action):
|
||||
self.match = m
|
||||
action = action(self, m.group())
|
||||
if action is not None:
|
||||
append(action)
|
||||
i = j
|
||||
return result, string[i:]
|
BIN
Dependencies/Python/Lib/re/__pycache__/__init__.cpython-313.pyc
vendored
Normal file
BIN
Dependencies/Python/Lib/re/__pycache__/__init__.cpython-313.pyc
vendored
Normal file
Binary file not shown.
BIN
Dependencies/Python/Lib/re/__pycache__/_casefix.cpython-313.pyc
vendored
Normal file
BIN
Dependencies/Python/Lib/re/__pycache__/_casefix.cpython-313.pyc
vendored
Normal file
Binary file not shown.
BIN
Dependencies/Python/Lib/re/__pycache__/_compiler.cpython-313.pyc
vendored
Normal file
BIN
Dependencies/Python/Lib/re/__pycache__/_compiler.cpython-313.pyc
vendored
Normal file
Binary file not shown.
BIN
Dependencies/Python/Lib/re/__pycache__/_constants.cpython-313.pyc
vendored
Normal file
BIN
Dependencies/Python/Lib/re/__pycache__/_constants.cpython-313.pyc
vendored
Normal file
Binary file not shown.
BIN
Dependencies/Python/Lib/re/__pycache__/_parser.cpython-313.pyc
vendored
Normal file
BIN
Dependencies/Python/Lib/re/__pycache__/_parser.cpython-313.pyc
vendored
Normal file
Binary file not shown.
106
Dependencies/Python/Lib/re/_casefix.py
vendored
Normal file
106
Dependencies/Python/Lib/re/_casefix.py
vendored
Normal file
@ -0,0 +1,106 @@
|
||||
# Auto-generated by Tools/build/generate_re_casefix.py.
|
||||
|
||||
# Maps the code of lowercased character to codes of different lowercased
|
||||
# characters which have the same uppercase.
|
||||
_EXTRA_CASES = {
|
||||
# LATIN SMALL LETTER I: LATIN SMALL LETTER DOTLESS I
|
||||
0x0069: (0x0131,), # 'i': 'ı'
|
||||
# LATIN SMALL LETTER S: LATIN SMALL LETTER LONG S
|
||||
0x0073: (0x017f,), # 's': 'ſ'
|
||||
# MICRO SIGN: GREEK SMALL LETTER MU
|
||||
0x00b5: (0x03bc,), # 'µ': 'μ'
|
||||
# LATIN SMALL LETTER DOTLESS I: LATIN SMALL LETTER I
|
||||
0x0131: (0x0069,), # 'ı': 'i'
|
||||
# LATIN SMALL LETTER LONG S: LATIN SMALL LETTER S
|
||||
0x017f: (0x0073,), # 'ſ': 's'
|
||||
# COMBINING GREEK YPOGEGRAMMENI: GREEK SMALL LETTER IOTA, GREEK PROSGEGRAMMENI
|
||||
0x0345: (0x03b9, 0x1fbe), # '\u0345': 'ιι'
|
||||
# GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS: GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
|
||||
0x0390: (0x1fd3,), # 'ΐ': 'ΐ'
|
||||
# GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS: GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
|
||||
0x03b0: (0x1fe3,), # 'ΰ': 'ΰ'
|
||||
# GREEK SMALL LETTER BETA: GREEK BETA SYMBOL
|
||||
0x03b2: (0x03d0,), # 'β': 'ϐ'
|
||||
# GREEK SMALL LETTER EPSILON: GREEK LUNATE EPSILON SYMBOL
|
||||
0x03b5: (0x03f5,), # 'ε': 'ϵ'
|
||||
# GREEK SMALL LETTER THETA: GREEK THETA SYMBOL
|
||||
0x03b8: (0x03d1,), # 'θ': 'ϑ'
|
||||
# GREEK SMALL LETTER IOTA: COMBINING GREEK YPOGEGRAMMENI, GREEK PROSGEGRAMMENI
|
||||
0x03b9: (0x0345, 0x1fbe), # 'ι': '\u0345ι'
|
||||
# GREEK SMALL LETTER KAPPA: GREEK KAPPA SYMBOL
|
||||
0x03ba: (0x03f0,), # 'κ': 'ϰ'
|
||||
# GREEK SMALL LETTER MU: MICRO SIGN
|
||||
0x03bc: (0x00b5,), # 'μ': 'µ'
|
||||
# GREEK SMALL LETTER PI: GREEK PI SYMBOL
|
||||
0x03c0: (0x03d6,), # 'π': 'ϖ'
|
||||
# GREEK SMALL LETTER RHO: GREEK RHO SYMBOL
|
||||
0x03c1: (0x03f1,), # 'ρ': 'ϱ'
|
||||
# GREEK SMALL LETTER FINAL SIGMA: GREEK SMALL LETTER SIGMA
|
||||
0x03c2: (0x03c3,), # 'ς': 'σ'
|
||||
# GREEK SMALL LETTER SIGMA: GREEK SMALL LETTER FINAL SIGMA
|
||||
0x03c3: (0x03c2,), # 'σ': 'ς'
|
||||
# GREEK SMALL LETTER PHI: GREEK PHI SYMBOL
|
||||
0x03c6: (0x03d5,), # 'φ': 'ϕ'
|
||||
# GREEK BETA SYMBOL: GREEK SMALL LETTER BETA
|
||||
0x03d0: (0x03b2,), # 'ϐ': 'β'
|
||||
# GREEK THETA SYMBOL: GREEK SMALL LETTER THETA
|
||||
0x03d1: (0x03b8,), # 'ϑ': 'θ'
|
||||
# GREEK PHI SYMBOL: GREEK SMALL LETTER PHI
|
||||
0x03d5: (0x03c6,), # 'ϕ': 'φ'
|
||||
# GREEK PI SYMBOL: GREEK SMALL LETTER PI
|
||||
0x03d6: (0x03c0,), # 'ϖ': 'π'
|
||||
# GREEK KAPPA SYMBOL: GREEK SMALL LETTER KAPPA
|
||||
0x03f0: (0x03ba,), # 'ϰ': 'κ'
|
||||
# GREEK RHO SYMBOL: GREEK SMALL LETTER RHO
|
||||
0x03f1: (0x03c1,), # 'ϱ': 'ρ'
|
||||
# GREEK LUNATE EPSILON SYMBOL: GREEK SMALL LETTER EPSILON
|
||||
0x03f5: (0x03b5,), # 'ϵ': 'ε'
|
||||
# CYRILLIC SMALL LETTER VE: CYRILLIC SMALL LETTER ROUNDED VE
|
||||
0x0432: (0x1c80,), # 'в': 'ᲀ'
|
||||
# CYRILLIC SMALL LETTER DE: CYRILLIC SMALL LETTER LONG-LEGGED DE
|
||||
0x0434: (0x1c81,), # 'д': 'ᲁ'
|
||||
# CYRILLIC SMALL LETTER O: CYRILLIC SMALL LETTER NARROW O
|
||||
0x043e: (0x1c82,), # 'о': 'ᲂ'
|
||||
# CYRILLIC SMALL LETTER ES: CYRILLIC SMALL LETTER WIDE ES
|
||||
0x0441: (0x1c83,), # 'с': 'ᲃ'
|
||||
# CYRILLIC SMALL LETTER TE: CYRILLIC SMALL LETTER TALL TE, CYRILLIC SMALL LETTER THREE-LEGGED TE
|
||||
0x0442: (0x1c84, 0x1c85), # 'т': 'ᲄᲅ'
|
||||
# CYRILLIC SMALL LETTER HARD SIGN: CYRILLIC SMALL LETTER TALL HARD SIGN
|
||||
0x044a: (0x1c86,), # 'ъ': 'ᲆ'
|
||||
# CYRILLIC SMALL LETTER YAT: CYRILLIC SMALL LETTER TALL YAT
|
||||
0x0463: (0x1c87,), # 'ѣ': 'ᲇ'
|
||||
# CYRILLIC SMALL LETTER ROUNDED VE: CYRILLIC SMALL LETTER VE
|
||||
0x1c80: (0x0432,), # 'ᲀ': 'в'
|
||||
# CYRILLIC SMALL LETTER LONG-LEGGED DE: CYRILLIC SMALL LETTER DE
|
||||
0x1c81: (0x0434,), # 'ᲁ': 'д'
|
||||
# CYRILLIC SMALL LETTER NARROW O: CYRILLIC SMALL LETTER O
|
||||
0x1c82: (0x043e,), # 'ᲂ': 'о'
|
||||
# CYRILLIC SMALL LETTER WIDE ES: CYRILLIC SMALL LETTER ES
|
||||
0x1c83: (0x0441,), # 'ᲃ': 'с'
|
||||
# CYRILLIC SMALL LETTER TALL TE: CYRILLIC SMALL LETTER TE, CYRILLIC SMALL LETTER THREE-LEGGED TE
|
||||
0x1c84: (0x0442, 0x1c85), # 'ᲄ': 'тᲅ'
|
||||
# CYRILLIC SMALL LETTER THREE-LEGGED TE: CYRILLIC SMALL LETTER TE, CYRILLIC SMALL LETTER TALL TE
|
||||
0x1c85: (0x0442, 0x1c84), # 'ᲅ': 'тᲄ'
|
||||
# CYRILLIC SMALL LETTER TALL HARD SIGN: CYRILLIC SMALL LETTER HARD SIGN
|
||||
0x1c86: (0x044a,), # 'ᲆ': 'ъ'
|
||||
# CYRILLIC SMALL LETTER TALL YAT: CYRILLIC SMALL LETTER YAT
|
||||
0x1c87: (0x0463,), # 'ᲇ': 'ѣ'
|
||||
# CYRILLIC SMALL LETTER UNBLENDED UK: CYRILLIC SMALL LETTER MONOGRAPH UK
|
||||
0x1c88: (0xa64b,), # 'ᲈ': 'ꙋ'
|
||||
# LATIN SMALL LETTER S WITH DOT ABOVE: LATIN SMALL LETTER LONG S WITH DOT ABOVE
|
||||
0x1e61: (0x1e9b,), # 'ṡ': 'ẛ'
|
||||
# LATIN SMALL LETTER LONG S WITH DOT ABOVE: LATIN SMALL LETTER S WITH DOT ABOVE
|
||||
0x1e9b: (0x1e61,), # 'ẛ': 'ṡ'
|
||||
# GREEK PROSGEGRAMMENI: COMBINING GREEK YPOGEGRAMMENI, GREEK SMALL LETTER IOTA
|
||||
0x1fbe: (0x0345, 0x03b9), # 'ι': '\u0345ι'
|
||||
# GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA: GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
|
||||
0x1fd3: (0x0390,), # 'ΐ': 'ΐ'
|
||||
# GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA: GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
|
||||
0x1fe3: (0x03b0,), # 'ΰ': 'ΰ'
|
||||
# CYRILLIC SMALL LETTER MONOGRAPH UK: CYRILLIC SMALL LETTER UNBLENDED UK
|
||||
0xa64b: (0x1c88,), # 'ꙋ': 'ᲈ'
|
||||
# LATIN SMALL LIGATURE LONG S T: LATIN SMALL LIGATURE ST
|
||||
0xfb05: (0xfb06,), # 'ſt': 'st'
|
||||
# LATIN SMALL LIGATURE ST: LATIN SMALL LIGATURE LONG S T
|
||||
0xfb06: (0xfb05,), # 'st': 'ſt'
|
||||
}
|
768
Dependencies/Python/Lib/re/_compiler.py
vendored
Normal file
768
Dependencies/Python/Lib/re/_compiler.py
vendored
Normal file
@ -0,0 +1,768 @@
|
||||
#
|
||||
# Secret Labs' Regular Expression Engine
|
||||
#
|
||||
# convert template to internal format
|
||||
#
|
||||
# Copyright (c) 1997-2001 by Secret Labs AB. All rights reserved.
|
||||
#
|
||||
# See the __init__.py file for information on usage and redistribution.
|
||||
#
|
||||
|
||||
"""Internal support module for sre"""
|
||||
|
||||
import _sre
|
||||
from . import _parser
|
||||
from ._constants import *
|
||||
from ._casefix import _EXTRA_CASES
|
||||
|
||||
assert _sre.MAGIC == MAGIC, "SRE module mismatch"
|
||||
|
||||
_LITERAL_CODES = {LITERAL, NOT_LITERAL}
|
||||
_SUCCESS_CODES = {SUCCESS, FAILURE}
|
||||
_ASSERT_CODES = {ASSERT, ASSERT_NOT}
|
||||
_UNIT_CODES = _LITERAL_CODES | {ANY, IN}
|
||||
|
||||
_REPEATING_CODES = {
|
||||
MIN_REPEAT: (REPEAT, MIN_UNTIL, MIN_REPEAT_ONE),
|
||||
MAX_REPEAT: (REPEAT, MAX_UNTIL, REPEAT_ONE),
|
||||
POSSESSIVE_REPEAT: (POSSESSIVE_REPEAT, SUCCESS, POSSESSIVE_REPEAT_ONE),
|
||||
}
|
||||
|
||||
def _combine_flags(flags, add_flags, del_flags,
|
||||
TYPE_FLAGS=_parser.TYPE_FLAGS):
|
||||
if add_flags & TYPE_FLAGS:
|
||||
flags &= ~TYPE_FLAGS
|
||||
return (flags | add_flags) & ~del_flags
|
||||
|
||||
def _compile(code, pattern, flags):
|
||||
# internal: compile a (sub)pattern
|
||||
emit = code.append
|
||||
_len = len
|
||||
LITERAL_CODES = _LITERAL_CODES
|
||||
REPEATING_CODES = _REPEATING_CODES
|
||||
SUCCESS_CODES = _SUCCESS_CODES
|
||||
ASSERT_CODES = _ASSERT_CODES
|
||||
iscased = None
|
||||
tolower = None
|
||||
fixes = None
|
||||
if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE:
|
||||
if flags & SRE_FLAG_UNICODE:
|
||||
iscased = _sre.unicode_iscased
|
||||
tolower = _sre.unicode_tolower
|
||||
fixes = _EXTRA_CASES
|
||||
else:
|
||||
iscased = _sre.ascii_iscased
|
||||
tolower = _sre.ascii_tolower
|
||||
for op, av in pattern:
|
||||
if op in LITERAL_CODES:
|
||||
if not flags & SRE_FLAG_IGNORECASE:
|
||||
emit(op)
|
||||
emit(av)
|
||||
elif flags & SRE_FLAG_LOCALE:
|
||||
emit(OP_LOCALE_IGNORE[op])
|
||||
emit(av)
|
||||
elif not iscased(av):
|
||||
emit(op)
|
||||
emit(av)
|
||||
else:
|
||||
lo = tolower(av)
|
||||
if not fixes: # ascii
|
||||
emit(OP_IGNORE[op])
|
||||
emit(lo)
|
||||
elif lo not in fixes:
|
||||
emit(OP_UNICODE_IGNORE[op])
|
||||
emit(lo)
|
||||
else:
|
||||
emit(IN_UNI_IGNORE)
|
||||
skip = _len(code); emit(0)
|
||||
if op is NOT_LITERAL:
|
||||
emit(NEGATE)
|
||||
for k in (lo,) + fixes[lo]:
|
||||
emit(LITERAL)
|
||||
emit(k)
|
||||
emit(FAILURE)
|
||||
code[skip] = _len(code) - skip
|
||||
elif op is IN:
|
||||
charset, hascased = _optimize_charset(av, iscased, tolower, fixes)
|
||||
if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE:
|
||||
emit(IN_LOC_IGNORE)
|
||||
elif not hascased:
|
||||
emit(IN)
|
||||
elif not fixes: # ascii
|
||||
emit(IN_IGNORE)
|
||||
else:
|
||||
emit(IN_UNI_IGNORE)
|
||||
skip = _len(code); emit(0)
|
||||
_compile_charset(charset, flags, code)
|
||||
code[skip] = _len(code) - skip
|
||||
elif op is ANY:
|
||||
if flags & SRE_FLAG_DOTALL:
|
||||
emit(ANY_ALL)
|
||||
else:
|
||||
emit(ANY)
|
||||
elif op in REPEATING_CODES:
|
||||
if _simple(av[2]):
|
||||
emit(REPEATING_CODES[op][2])
|
||||
skip = _len(code); emit(0)
|
||||
emit(av[0])
|
||||
emit(av[1])
|
||||
_compile(code, av[2], flags)
|
||||
emit(SUCCESS)
|
||||
code[skip] = _len(code) - skip
|
||||
else:
|
||||
emit(REPEATING_CODES[op][0])
|
||||
skip = _len(code); emit(0)
|
||||
emit(av[0])
|
||||
emit(av[1])
|
||||
_compile(code, av[2], flags)
|
||||
code[skip] = _len(code) - skip
|
||||
emit(REPEATING_CODES[op][1])
|
||||
elif op is SUBPATTERN:
|
||||
group, add_flags, del_flags, p = av
|
||||
if group:
|
||||
emit(MARK)
|
||||
emit((group-1)*2)
|
||||
# _compile_info(code, p, _combine_flags(flags, add_flags, del_flags))
|
||||
_compile(code, p, _combine_flags(flags, add_flags, del_flags))
|
||||
if group:
|
||||
emit(MARK)
|
||||
emit((group-1)*2+1)
|
||||
elif op is ATOMIC_GROUP:
|
||||
# Atomic Groups are handled by starting with an Atomic
|
||||
# Group op code, then putting in the atomic group pattern
|
||||
# and finally a success op code to tell any repeat
|
||||
# operations within the Atomic Group to stop eating and
|
||||
# pop their stack if they reach it
|
||||
emit(ATOMIC_GROUP)
|
||||
skip = _len(code); emit(0)
|
||||
_compile(code, av, flags)
|
||||
emit(SUCCESS)
|
||||
code[skip] = _len(code) - skip
|
||||
elif op in SUCCESS_CODES:
|
||||
emit(op)
|
||||
elif op in ASSERT_CODES:
|
||||
emit(op)
|
||||
skip = _len(code); emit(0)
|
||||
if av[0] >= 0:
|
||||
emit(0) # look ahead
|
||||
else:
|
||||
lo, hi = av[1].getwidth()
|
||||
if lo > MAXCODE:
|
||||
raise error("looks too much behind")
|
||||
if lo != hi:
|
||||
raise PatternError("look-behind requires fixed-width pattern")
|
||||
emit(lo) # look behind
|
||||
_compile(code, av[1], flags)
|
||||
emit(SUCCESS)
|
||||
code[skip] = _len(code) - skip
|
||||
elif op is AT:
|
||||
emit(op)
|
||||
if flags & SRE_FLAG_MULTILINE:
|
||||
av = AT_MULTILINE.get(av, av)
|
||||
if flags & SRE_FLAG_LOCALE:
|
||||
av = AT_LOCALE.get(av, av)
|
||||
elif flags & SRE_FLAG_UNICODE:
|
||||
av = AT_UNICODE.get(av, av)
|
||||
emit(av)
|
||||
elif op is BRANCH:
|
||||
emit(op)
|
||||
tail = []
|
||||
tailappend = tail.append
|
||||
for av in av[1]:
|
||||
skip = _len(code); emit(0)
|
||||
# _compile_info(code, av, flags)
|
||||
_compile(code, av, flags)
|
||||
emit(JUMP)
|
||||
tailappend(_len(code)); emit(0)
|
||||
code[skip] = _len(code) - skip
|
||||
emit(FAILURE) # end of branch
|
||||
for tail in tail:
|
||||
code[tail] = _len(code) - tail
|
||||
elif op is CATEGORY:
|
||||
emit(op)
|
||||
if flags & SRE_FLAG_LOCALE:
|
||||
av = CH_LOCALE[av]
|
||||
elif flags & SRE_FLAG_UNICODE:
|
||||
av = CH_UNICODE[av]
|
||||
emit(av)
|
||||
elif op is GROUPREF:
|
||||
if not flags & SRE_FLAG_IGNORECASE:
|
||||
emit(op)
|
||||
elif flags & SRE_FLAG_LOCALE:
|
||||
emit(GROUPREF_LOC_IGNORE)
|
||||
elif not fixes: # ascii
|
||||
emit(GROUPREF_IGNORE)
|
||||
else:
|
||||
emit(GROUPREF_UNI_IGNORE)
|
||||
emit(av-1)
|
||||
elif op is GROUPREF_EXISTS:
|
||||
emit(op)
|
||||
emit(av[0]-1)
|
||||
skipyes = _len(code); emit(0)
|
||||
_compile(code, av[1], flags)
|
||||
if av[2]:
|
||||
emit(JUMP)
|
||||
skipno = _len(code); emit(0)
|
||||
code[skipyes] = _len(code) - skipyes + 1
|
||||
_compile(code, av[2], flags)
|
||||
code[skipno] = _len(code) - skipno
|
||||
else:
|
||||
code[skipyes] = _len(code) - skipyes + 1
|
||||
else:
|
||||
raise PatternError(f"internal: unsupported operand type {op!r}")
|
||||
|
||||
def _compile_charset(charset, flags, code):
|
||||
# compile charset subprogram
|
||||
emit = code.append
|
||||
for op, av in charset:
|
||||
emit(op)
|
||||
if op is NEGATE:
|
||||
pass
|
||||
elif op is LITERAL:
|
||||
emit(av)
|
||||
elif op is RANGE or op is RANGE_UNI_IGNORE:
|
||||
emit(av[0])
|
||||
emit(av[1])
|
||||
elif op is CHARSET:
|
||||
code.extend(av)
|
||||
elif op is BIGCHARSET:
|
||||
code.extend(av)
|
||||
elif op is CATEGORY:
|
||||
if flags & SRE_FLAG_LOCALE:
|
||||
emit(CH_LOCALE[av])
|
||||
elif flags & SRE_FLAG_UNICODE:
|
||||
emit(CH_UNICODE[av])
|
||||
else:
|
||||
emit(av)
|
||||
else:
|
||||
raise PatternError(f"internal: unsupported set operator {op!r}")
|
||||
emit(FAILURE)
|
||||
|
||||
def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
|
||||
# internal: optimize character set
|
||||
out = []
|
||||
tail = []
|
||||
charmap = bytearray(256)
|
||||
hascased = False
|
||||
for op, av in charset:
|
||||
while True:
|
||||
try:
|
||||
if op is LITERAL:
|
||||
if fixup: # IGNORECASE and not LOCALE
|
||||
av = fixup(av)
|
||||
charmap[av] = 1
|
||||
if fixes and av in fixes:
|
||||
for k in fixes[av]:
|
||||
charmap[k] = 1
|
||||
if not hascased and iscased(av):
|
||||
hascased = True
|
||||
else:
|
||||
charmap[av] = 1
|
||||
elif op is RANGE:
|
||||
r = range(av[0], av[1]+1)
|
||||
if fixup: # IGNORECASE and not LOCALE
|
||||
if fixes:
|
||||
for i in map(fixup, r):
|
||||
charmap[i] = 1
|
||||
if i in fixes:
|
||||
for k in fixes[i]:
|
||||
charmap[k] = 1
|
||||
else:
|
||||
for i in map(fixup, r):
|
||||
charmap[i] = 1
|
||||
if not hascased:
|
||||
hascased = any(map(iscased, r))
|
||||
else:
|
||||
for i in r:
|
||||
charmap[i] = 1
|
||||
elif op is NEGATE:
|
||||
out.append((op, av))
|
||||
else:
|
||||
tail.append((op, av))
|
||||
except IndexError:
|
||||
if len(charmap) == 256:
|
||||
# character set contains non-UCS1 character codes
|
||||
charmap += b'\0' * 0xff00
|
||||
continue
|
||||
# Character set contains non-BMP character codes.
|
||||
# For range, all BMP characters in the range are already
|
||||
# proceeded.
|
||||
if fixup: # IGNORECASE and not LOCALE
|
||||
# For now, IN_UNI_IGNORE+LITERAL and
|
||||
# IN_UNI_IGNORE+RANGE_UNI_IGNORE work for all non-BMP
|
||||
# characters, because two characters (at least one of
|
||||
# which is not in the BMP) match case-insensitively
|
||||
# if and only if:
|
||||
# 1) c1.lower() == c2.lower()
|
||||
# 2) c1.lower() == c2 or c1.lower().upper() == c2
|
||||
# Also, both c.lower() and c.lower().upper() are single
|
||||
# characters for every non-BMP character.
|
||||
if op is RANGE:
|
||||
if fixes: # not ASCII
|
||||
op = RANGE_UNI_IGNORE
|
||||
hascased = True
|
||||
else:
|
||||
assert op is LITERAL
|
||||
if not hascased and iscased(av):
|
||||
hascased = True
|
||||
tail.append((op, av))
|
||||
break
|
||||
|
||||
# compress character map
|
||||
runs = []
|
||||
q = 0
|
||||
while True:
|
||||
p = charmap.find(1, q)
|
||||
if p < 0:
|
||||
break
|
||||
if len(runs) >= 2:
|
||||
runs = None
|
||||
break
|
||||
q = charmap.find(0, p)
|
||||
if q < 0:
|
||||
runs.append((p, len(charmap)))
|
||||
break
|
||||
runs.append((p, q))
|
||||
if runs is not None:
|
||||
# use literal/range
|
||||
for p, q in runs:
|
||||
if q - p == 1:
|
||||
out.append((LITERAL, p))
|
||||
else:
|
||||
out.append((RANGE, (p, q - 1)))
|
||||
out += tail
|
||||
# if the case was changed or new representation is more compact
|
||||
if hascased or len(out) < len(charset):
|
||||
return out, hascased
|
||||
# else original character set is good enough
|
||||
return charset, hascased
|
||||
|
||||
# use bitmap
|
||||
if len(charmap) == 256:
|
||||
data = _mk_bitmap(charmap)
|
||||
out.append((CHARSET, data))
|
||||
out += tail
|
||||
return out, hascased
|
||||
|
||||
# To represent a big charset, first a bitmap of all characters in the
|
||||
# set is constructed. Then, this bitmap is sliced into chunks of 256
|
||||
# characters, duplicate chunks are eliminated, and each chunk is
|
||||
# given a number. In the compiled expression, the charset is
|
||||
# represented by a 32-bit word sequence, consisting of one word for
|
||||
# the number of different chunks, a sequence of 256 bytes (64 words)
|
||||
# of chunk numbers indexed by their original chunk position, and a
|
||||
# sequence of 256-bit chunks (8 words each).
|
||||
|
||||
# Compression is normally good: in a typical charset, large ranges of
|
||||
# Unicode will be either completely excluded (e.g. if only cyrillic
|
||||
# letters are to be matched), or completely included (e.g. if large
|
||||
# subranges of Kanji match). These ranges will be represented by
|
||||
# chunks of all one-bits or all zero-bits.
|
||||
|
||||
# Matching can be also done efficiently: the more significant byte of
|
||||
# the Unicode character is an index into the chunk number, and the
|
||||
# less significant byte is a bit index in the chunk (just like the
|
||||
# CHARSET matching).
|
||||
|
||||
charmap = bytes(charmap) # should be hashable
|
||||
comps = {}
|
||||
mapping = bytearray(256)
|
||||
block = 0
|
||||
data = bytearray()
|
||||
for i in range(0, 65536, 256):
|
||||
chunk = charmap[i: i + 256]
|
||||
if chunk in comps:
|
||||
mapping[i // 256] = comps[chunk]
|
||||
else:
|
||||
mapping[i // 256] = comps[chunk] = block
|
||||
block += 1
|
||||
data += chunk
|
||||
data = _mk_bitmap(data)
|
||||
data[0:0] = [block] + _bytes_to_codes(mapping)
|
||||
out.append((BIGCHARSET, data))
|
||||
out += tail
|
||||
return out, hascased
|
||||
|
||||
_CODEBITS = _sre.CODESIZE * 8
|
||||
MAXCODE = (1 << _CODEBITS) - 1
|
||||
_BITS_TRANS = b'0' + b'1' * 255
|
||||
def _mk_bitmap(bits, _CODEBITS=_CODEBITS, _int=int):
|
||||
s = bits.translate(_BITS_TRANS)[::-1]
|
||||
return [_int(s[i - _CODEBITS: i], 2)
|
||||
for i in range(len(s), 0, -_CODEBITS)]
|
||||
|
||||
def _bytes_to_codes(b):
|
||||
# Convert block indices to word array
|
||||
a = memoryview(b).cast('I')
|
||||
assert a.itemsize == _sre.CODESIZE
|
||||
assert len(a) * a.itemsize == len(b)
|
||||
return a.tolist()
|
||||
|
||||
def _simple(p):
|
||||
# check if this subpattern is a "simple" operator
|
||||
if len(p) != 1:
|
||||
return False
|
||||
op, av = p[0]
|
||||
if op is SUBPATTERN:
|
||||
return av[0] is None and _simple(av[-1])
|
||||
return op in _UNIT_CODES
|
||||
|
||||
def _generate_overlap_table(prefix):
|
||||
"""
|
||||
Generate an overlap table for the following prefix.
|
||||
An overlap table is a table of the same size as the prefix which
|
||||
informs about the potential self-overlap for each index in the prefix:
|
||||
- if overlap[i] == 0, prefix[i:] can't overlap prefix[0:...]
|
||||
- if overlap[i] == k with 0 < k <= i, prefix[i-k+1:i+1] overlaps with
|
||||
prefix[0:k]
|
||||
"""
|
||||
table = [0] * len(prefix)
|
||||
for i in range(1, len(prefix)):
|
||||
idx = table[i - 1]
|
||||
while prefix[i] != prefix[idx]:
|
||||
if idx == 0:
|
||||
table[i] = 0
|
||||
break
|
||||
idx = table[idx - 1]
|
||||
else:
|
||||
table[i] = idx + 1
|
||||
return table
|
||||
|
||||
def _get_iscased(flags):
|
||||
if not flags & SRE_FLAG_IGNORECASE:
|
||||
return None
|
||||
elif flags & SRE_FLAG_UNICODE:
|
||||
return _sre.unicode_iscased
|
||||
else:
|
||||
return _sre.ascii_iscased
|
||||
|
||||
def _get_literal_prefix(pattern, flags):
|
||||
# look for literal prefix
|
||||
prefix = []
|
||||
prefixappend = prefix.append
|
||||
prefix_skip = None
|
||||
iscased = _get_iscased(flags)
|
||||
for op, av in pattern.data:
|
||||
if op is LITERAL:
|
||||
if iscased and iscased(av):
|
||||
break
|
||||
prefixappend(av)
|
||||
elif op is SUBPATTERN:
|
||||
group, add_flags, del_flags, p = av
|
||||
flags1 = _combine_flags(flags, add_flags, del_flags)
|
||||
if flags1 & SRE_FLAG_IGNORECASE and flags1 & SRE_FLAG_LOCALE:
|
||||
break
|
||||
prefix1, prefix_skip1, got_all = _get_literal_prefix(p, flags1)
|
||||
if prefix_skip is None:
|
||||
if group is not None:
|
||||
prefix_skip = len(prefix)
|
||||
elif prefix_skip1 is not None:
|
||||
prefix_skip = len(prefix) + prefix_skip1
|
||||
prefix.extend(prefix1)
|
||||
if not got_all:
|
||||
break
|
||||
else:
|
||||
break
|
||||
else:
|
||||
return prefix, prefix_skip, True
|
||||
return prefix, prefix_skip, False
|
||||
|
||||
def _get_charset_prefix(pattern, flags):
|
||||
while True:
|
||||
if not pattern.data:
|
||||
return None
|
||||
op, av = pattern.data[0]
|
||||
if op is not SUBPATTERN:
|
||||
break
|
||||
group, add_flags, del_flags, pattern = av
|
||||
flags = _combine_flags(flags, add_flags, del_flags)
|
||||
if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE:
|
||||
return None
|
||||
|
||||
iscased = _get_iscased(flags)
|
||||
if op is LITERAL:
|
||||
if iscased and iscased(av):
|
||||
return None
|
||||
return [(op, av)]
|
||||
elif op is BRANCH:
|
||||
charset = []
|
||||
charsetappend = charset.append
|
||||
for p in av[1]:
|
||||
if not p:
|
||||
return None
|
||||
op, av = p[0]
|
||||
if op is LITERAL and not (iscased and iscased(av)):
|
||||
charsetappend((op, av))
|
||||
else:
|
||||
return None
|
||||
return charset
|
||||
elif op is IN:
|
||||
charset = av
|
||||
if iscased:
|
||||
for op, av in charset:
|
||||
if op is LITERAL:
|
||||
if iscased(av):
|
||||
return None
|
||||
elif op is RANGE:
|
||||
if av[1] > 0xffff:
|
||||
return None
|
||||
if any(map(iscased, range(av[0], av[1]+1))):
|
||||
return None
|
||||
return charset
|
||||
return None
|
||||
|
||||
def _compile_info(code, pattern, flags):
|
||||
# internal: compile an info block. in the current version,
|
||||
# this contains min/max pattern width, and an optional literal
|
||||
# prefix or a character map
|
||||
lo, hi = pattern.getwidth()
|
||||
if hi > MAXCODE:
|
||||
hi = MAXCODE
|
||||
if lo == 0:
|
||||
code.extend([INFO, 4, 0, lo, hi])
|
||||
return
|
||||
# look for a literal prefix
|
||||
prefix = []
|
||||
prefix_skip = 0
|
||||
charset = [] # not used
|
||||
if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE):
|
||||
# look for literal prefix
|
||||
prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags)
|
||||
# if no prefix, look for charset prefix
|
||||
if not prefix:
|
||||
charset = _get_charset_prefix(pattern, flags)
|
||||
## if prefix:
|
||||
## print("*** PREFIX", prefix, prefix_skip)
|
||||
## if charset:
|
||||
## print("*** CHARSET", charset)
|
||||
# add an info block
|
||||
emit = code.append
|
||||
emit(INFO)
|
||||
skip = len(code); emit(0)
|
||||
# literal flag
|
||||
mask = 0
|
||||
if prefix:
|
||||
mask = SRE_INFO_PREFIX
|
||||
if prefix_skip is None and got_all:
|
||||
mask = mask | SRE_INFO_LITERAL
|
||||
elif charset:
|
||||
mask = mask | SRE_INFO_CHARSET
|
||||
emit(mask)
|
||||
# pattern length
|
||||
if lo < MAXCODE:
|
||||
emit(lo)
|
||||
else:
|
||||
emit(MAXCODE)
|
||||
prefix = prefix[:MAXCODE]
|
||||
emit(hi)
|
||||
# add literal prefix
|
||||
if prefix:
|
||||
emit(len(prefix)) # length
|
||||
if prefix_skip is None:
|
||||
prefix_skip = len(prefix)
|
||||
emit(prefix_skip) # skip
|
||||
code.extend(prefix)
|
||||
# generate overlap table
|
||||
code.extend(_generate_overlap_table(prefix))
|
||||
elif charset:
|
||||
charset, hascased = _optimize_charset(charset)
|
||||
assert not hascased
|
||||
_compile_charset(charset, flags, code)
|
||||
code[skip] = len(code) - skip
|
||||
|
||||
def isstring(obj):
|
||||
return isinstance(obj, (str, bytes))
|
||||
|
||||
def _code(p, flags):
|
||||
|
||||
flags = p.state.flags | flags
|
||||
code = []
|
||||
|
||||
# compile info block
|
||||
_compile_info(code, p, flags)
|
||||
|
||||
# compile the pattern
|
||||
_compile(code, p.data, flags)
|
||||
|
||||
code.append(SUCCESS)
|
||||
|
||||
return code
|
||||
|
||||
def _hex_code(code):
|
||||
return '[%s]' % ', '.join('%#0*x' % (_sre.CODESIZE*2+2, x) for x in code)
|
||||
|
||||
def dis(code):
|
||||
import sys
|
||||
|
||||
labels = set()
|
||||
level = 0
|
||||
offset_width = len(str(len(code) - 1))
|
||||
|
||||
def dis_(start, end):
|
||||
def print_(*args, to=None):
|
||||
if to is not None:
|
||||
labels.add(to)
|
||||
args += ('(to %d)' % (to,),)
|
||||
print('%*d%s ' % (offset_width, start, ':' if start in labels else '.'),
|
||||
end=' '*(level-1))
|
||||
print(*args)
|
||||
|
||||
def print_2(*args):
|
||||
print(end=' '*(offset_width + 2*level))
|
||||
print(*args)
|
||||
|
||||
nonlocal level
|
||||
level += 1
|
||||
i = start
|
||||
while i < end:
|
||||
start = i
|
||||
op = code[i]
|
||||
i += 1
|
||||
op = OPCODES[op]
|
||||
if op in (SUCCESS, FAILURE, ANY, ANY_ALL,
|
||||
MAX_UNTIL, MIN_UNTIL, NEGATE):
|
||||
print_(op)
|
||||
elif op in (LITERAL, NOT_LITERAL,
|
||||
LITERAL_IGNORE, NOT_LITERAL_IGNORE,
|
||||
LITERAL_UNI_IGNORE, NOT_LITERAL_UNI_IGNORE,
|
||||
LITERAL_LOC_IGNORE, NOT_LITERAL_LOC_IGNORE):
|
||||
arg = code[i]
|
||||
i += 1
|
||||
print_(op, '%#02x (%r)' % (arg, chr(arg)))
|
||||
elif op is AT:
|
||||
arg = code[i]
|
||||
i += 1
|
||||
arg = str(ATCODES[arg])
|
||||
assert arg[:3] == 'AT_'
|
||||
print_(op, arg[3:])
|
||||
elif op is CATEGORY:
|
||||
arg = code[i]
|
||||
i += 1
|
||||
arg = str(CHCODES[arg])
|
||||
assert arg[:9] == 'CATEGORY_'
|
||||
print_(op, arg[9:])
|
||||
elif op in (IN, IN_IGNORE, IN_UNI_IGNORE, IN_LOC_IGNORE):
|
||||
skip = code[i]
|
||||
print_(op, skip, to=i+skip)
|
||||
dis_(i+1, i+skip)
|
||||
i += skip
|
||||
elif op in (RANGE, RANGE_UNI_IGNORE):
|
||||
lo, hi = code[i: i+2]
|
||||
i += 2
|
||||
print_(op, '%#02x %#02x (%r-%r)' % (lo, hi, chr(lo), chr(hi)))
|
||||
elif op is CHARSET:
|
||||
print_(op, _hex_code(code[i: i + 256//_CODEBITS]))
|
||||
i += 256//_CODEBITS
|
||||
elif op is BIGCHARSET:
|
||||
arg = code[i]
|
||||
i += 1
|
||||
mapping = list(b''.join(x.to_bytes(_sre.CODESIZE, sys.byteorder)
|
||||
for x in code[i: i + 256//_sre.CODESIZE]))
|
||||
print_(op, arg, mapping)
|
||||
i += 256//_sre.CODESIZE
|
||||
level += 1
|
||||
for j in range(arg):
|
||||
print_2(_hex_code(code[i: i + 256//_CODEBITS]))
|
||||
i += 256//_CODEBITS
|
||||
level -= 1
|
||||
elif op in (MARK, GROUPREF, GROUPREF_IGNORE, GROUPREF_UNI_IGNORE,
|
||||
GROUPREF_LOC_IGNORE):
|
||||
arg = code[i]
|
||||
i += 1
|
||||
print_(op, arg)
|
||||
elif op is JUMP:
|
||||
skip = code[i]
|
||||
print_(op, skip, to=i+skip)
|
||||
i += 1
|
||||
elif op is BRANCH:
|
||||
skip = code[i]
|
||||
print_(op, skip, to=i+skip)
|
||||
while skip:
|
||||
dis_(i+1, i+skip)
|
||||
i += skip
|
||||
start = i
|
||||
skip = code[i]
|
||||
if skip:
|
||||
print_('branch', skip, to=i+skip)
|
||||
else:
|
||||
print_(FAILURE)
|
||||
i += 1
|
||||
elif op in (REPEAT, REPEAT_ONE, MIN_REPEAT_ONE,
|
||||
POSSESSIVE_REPEAT, POSSESSIVE_REPEAT_ONE):
|
||||
skip, min, max = code[i: i+3]
|
||||
if max == MAXREPEAT:
|
||||
max = 'MAXREPEAT'
|
||||
print_(op, skip, min, max, to=i+skip)
|
||||
dis_(i+3, i+skip)
|
||||
i += skip
|
||||
elif op is GROUPREF_EXISTS:
|
||||
arg, skip = code[i: i+2]
|
||||
print_(op, arg, skip, to=i+skip)
|
||||
i += 2
|
||||
elif op in (ASSERT, ASSERT_NOT):
|
||||
skip, arg = code[i: i+2]
|
||||
print_(op, skip, arg, to=i+skip)
|
||||
dis_(i+2, i+skip)
|
||||
i += skip
|
||||
elif op is ATOMIC_GROUP:
|
||||
skip = code[i]
|
||||
print_(op, skip, to=i+skip)
|
||||
dis_(i+1, i+skip)
|
||||
i += skip
|
||||
elif op is INFO:
|
||||
skip, flags, min, max = code[i: i+4]
|
||||
if max == MAXREPEAT:
|
||||
max = 'MAXREPEAT'
|
||||
print_(op, skip, bin(flags), min, max, to=i+skip)
|
||||
start = i+4
|
||||
if flags & SRE_INFO_PREFIX:
|
||||
prefix_len, prefix_skip = code[i+4: i+6]
|
||||
print_2(' prefix_skip', prefix_skip)
|
||||
start = i + 6
|
||||
prefix = code[start: start+prefix_len]
|
||||
print_2(' prefix',
|
||||
'[%s]' % ', '.join('%#02x' % x for x in prefix),
|
||||
'(%r)' % ''.join(map(chr, prefix)))
|
||||
start += prefix_len
|
||||
print_2(' overlap', code[start: start+prefix_len])
|
||||
start += prefix_len
|
||||
if flags & SRE_INFO_CHARSET:
|
||||
level += 1
|
||||
print_2('in')
|
||||
dis_(start, i+skip)
|
||||
level -= 1
|
||||
i += skip
|
||||
else:
|
||||
raise ValueError(op)
|
||||
|
||||
level -= 1
|
||||
|
||||
dis_(0, len(code))
|
||||
|
||||
|
||||
def compile(p, flags=0):
|
||||
# internal: convert pattern list to internal format
|
||||
|
||||
if isstring(p):
|
||||
pattern = p
|
||||
p = _parser.parse(p, flags)
|
||||
else:
|
||||
pattern = None
|
||||
|
||||
code = _code(p, flags)
|
||||
|
||||
if flags & SRE_FLAG_DEBUG:
|
||||
print()
|
||||
dis(code)
|
||||
|
||||
# map in either direction
|
||||
groupindex = p.state.groupdict
|
||||
indexgroup = [None] * p.state.groups
|
||||
for k, i in groupindex.items():
|
||||
indexgroup[i] = k
|
||||
|
||||
return _sre.compile(
|
||||
pattern, flags | p.state.flags, code,
|
||||
p.state.groups-1,
|
||||
groupindex, tuple(indexgroup)
|
||||
)
|
222
Dependencies/Python/Lib/re/_constants.py
vendored
Normal file
222
Dependencies/Python/Lib/re/_constants.py
vendored
Normal file
@ -0,0 +1,222 @@
|
||||
#
|
||||
# Secret Labs' Regular Expression Engine
|
||||
#
|
||||
# various symbols used by the regular expression engine.
|
||||
# run this script to update the _sre include files!
|
||||
#
|
||||
# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
|
||||
#
|
||||
# See the __init__.py file for information on usage and redistribution.
|
||||
#
|
||||
|
||||
"""Internal support module for sre"""
|
||||
|
||||
# update when constants are added or removed
|
||||
|
||||
MAGIC = 20230612
|
||||
|
||||
from _sre import MAXREPEAT, MAXGROUPS
|
||||
|
||||
# SRE standard exception (access as sre.error)
|
||||
# should this really be here?
|
||||
|
||||
class PatternError(Exception):
|
||||
"""Exception raised for invalid regular expressions.
|
||||
|
||||
Attributes:
|
||||
|
||||
msg: The unformatted error message
|
||||
pattern: The regular expression pattern
|
||||
pos: The index in the pattern where compilation failed (may be None)
|
||||
lineno: The line corresponding to pos (may be None)
|
||||
colno: The column corresponding to pos (may be None)
|
||||
"""
|
||||
|
||||
__module__ = 're'
|
||||
|
||||
def __init__(self, msg, pattern=None, pos=None):
|
||||
self.msg = msg
|
||||
self.pattern = pattern
|
||||
self.pos = pos
|
||||
if pattern is not None and pos is not None:
|
||||
msg = '%s at position %d' % (msg, pos)
|
||||
if isinstance(pattern, str):
|
||||
newline = '\n'
|
||||
else:
|
||||
newline = b'\n'
|
||||
self.lineno = pattern.count(newline, 0, pos) + 1
|
||||
self.colno = pos - pattern.rfind(newline, 0, pos)
|
||||
if newline in pattern:
|
||||
msg = '%s (line %d, column %d)' % (msg, self.lineno, self.colno)
|
||||
else:
|
||||
self.lineno = self.colno = None
|
||||
super().__init__(msg)
|
||||
|
||||
|
||||
# Backward compatibility after renaming in 3.13
|
||||
error = PatternError
|
||||
|
||||
class _NamedIntConstant(int):
|
||||
def __new__(cls, value, name):
|
||||
self = super(_NamedIntConstant, cls).__new__(cls, value)
|
||||
self.name = name
|
||||
return self
|
||||
|
||||
def __repr__(self):
|
||||
return self.name
|
||||
|
||||
__reduce__ = None
|
||||
|
||||
MAXREPEAT = _NamedIntConstant(MAXREPEAT, 'MAXREPEAT')
|
||||
|
||||
def _makecodes(*names):
|
||||
items = [_NamedIntConstant(i, name) for i, name in enumerate(names)]
|
||||
globals().update({item.name: item for item in items})
|
||||
return items
|
||||
|
||||
# operators
|
||||
OPCODES = _makecodes(
|
||||
# failure=0 success=1 (just because it looks better that way :-)
|
||||
'FAILURE', 'SUCCESS',
|
||||
|
||||
'ANY', 'ANY_ALL',
|
||||
'ASSERT', 'ASSERT_NOT',
|
||||
'AT',
|
||||
'BRANCH',
|
||||
'CATEGORY',
|
||||
'CHARSET', 'BIGCHARSET',
|
||||
'GROUPREF', 'GROUPREF_EXISTS',
|
||||
'IN',
|
||||
'INFO',
|
||||
'JUMP',
|
||||
'LITERAL',
|
||||
'MARK',
|
||||
'MAX_UNTIL',
|
||||
'MIN_UNTIL',
|
||||
'NOT_LITERAL',
|
||||
'NEGATE',
|
||||
'RANGE',
|
||||
'REPEAT',
|
||||
'REPEAT_ONE',
|
||||
'SUBPATTERN',
|
||||
'MIN_REPEAT_ONE',
|
||||
'ATOMIC_GROUP',
|
||||
'POSSESSIVE_REPEAT',
|
||||
'POSSESSIVE_REPEAT_ONE',
|
||||
|
||||
'GROUPREF_IGNORE',
|
||||
'IN_IGNORE',
|
||||
'LITERAL_IGNORE',
|
||||
'NOT_LITERAL_IGNORE',
|
||||
|
||||
'GROUPREF_LOC_IGNORE',
|
||||
'IN_LOC_IGNORE',
|
||||
'LITERAL_LOC_IGNORE',
|
||||
'NOT_LITERAL_LOC_IGNORE',
|
||||
|
||||
'GROUPREF_UNI_IGNORE',
|
||||
'IN_UNI_IGNORE',
|
||||
'LITERAL_UNI_IGNORE',
|
||||
'NOT_LITERAL_UNI_IGNORE',
|
||||
'RANGE_UNI_IGNORE',
|
||||
|
||||
# The following opcodes are only occurred in the parser output,
|
||||
# but not in the compiled code.
|
||||
'MIN_REPEAT', 'MAX_REPEAT',
|
||||
)
|
||||
del OPCODES[-2:] # remove MIN_REPEAT and MAX_REPEAT
|
||||
|
||||
# positions
|
||||
ATCODES = _makecodes(
|
||||
'AT_BEGINNING', 'AT_BEGINNING_LINE', 'AT_BEGINNING_STRING',
|
||||
'AT_BOUNDARY', 'AT_NON_BOUNDARY',
|
||||
'AT_END', 'AT_END_LINE', 'AT_END_STRING',
|
||||
|
||||
'AT_LOC_BOUNDARY', 'AT_LOC_NON_BOUNDARY',
|
||||
|
||||
'AT_UNI_BOUNDARY', 'AT_UNI_NON_BOUNDARY',
|
||||
)
|
||||
|
||||
# categories
|
||||
CHCODES = _makecodes(
|
||||
'CATEGORY_DIGIT', 'CATEGORY_NOT_DIGIT',
|
||||
'CATEGORY_SPACE', 'CATEGORY_NOT_SPACE',
|
||||
'CATEGORY_WORD', 'CATEGORY_NOT_WORD',
|
||||
'CATEGORY_LINEBREAK', 'CATEGORY_NOT_LINEBREAK',
|
||||
|
||||
'CATEGORY_LOC_WORD', 'CATEGORY_LOC_NOT_WORD',
|
||||
|
||||
'CATEGORY_UNI_DIGIT', 'CATEGORY_UNI_NOT_DIGIT',
|
||||
'CATEGORY_UNI_SPACE', 'CATEGORY_UNI_NOT_SPACE',
|
||||
'CATEGORY_UNI_WORD', 'CATEGORY_UNI_NOT_WORD',
|
||||
'CATEGORY_UNI_LINEBREAK', 'CATEGORY_UNI_NOT_LINEBREAK',
|
||||
)
|
||||
|
||||
|
||||
# replacement operations for "ignore case" mode
|
||||
OP_IGNORE = {
|
||||
LITERAL: LITERAL_IGNORE,
|
||||
NOT_LITERAL: NOT_LITERAL_IGNORE,
|
||||
}
|
||||
|
||||
OP_LOCALE_IGNORE = {
|
||||
LITERAL: LITERAL_LOC_IGNORE,
|
||||
NOT_LITERAL: NOT_LITERAL_LOC_IGNORE,
|
||||
}
|
||||
|
||||
OP_UNICODE_IGNORE = {
|
||||
LITERAL: LITERAL_UNI_IGNORE,
|
||||
NOT_LITERAL: NOT_LITERAL_UNI_IGNORE,
|
||||
}
|
||||
|
||||
AT_MULTILINE = {
|
||||
AT_BEGINNING: AT_BEGINNING_LINE,
|
||||
AT_END: AT_END_LINE
|
||||
}
|
||||
|
||||
AT_LOCALE = {
|
||||
AT_BOUNDARY: AT_LOC_BOUNDARY,
|
||||
AT_NON_BOUNDARY: AT_LOC_NON_BOUNDARY
|
||||
}
|
||||
|
||||
AT_UNICODE = {
|
||||
AT_BOUNDARY: AT_UNI_BOUNDARY,
|
||||
AT_NON_BOUNDARY: AT_UNI_NON_BOUNDARY
|
||||
}
|
||||
|
||||
CH_LOCALE = {
|
||||
CATEGORY_DIGIT: CATEGORY_DIGIT,
|
||||
CATEGORY_NOT_DIGIT: CATEGORY_NOT_DIGIT,
|
||||
CATEGORY_SPACE: CATEGORY_SPACE,
|
||||
CATEGORY_NOT_SPACE: CATEGORY_NOT_SPACE,
|
||||
CATEGORY_WORD: CATEGORY_LOC_WORD,
|
||||
CATEGORY_NOT_WORD: CATEGORY_LOC_NOT_WORD,
|
||||
CATEGORY_LINEBREAK: CATEGORY_LINEBREAK,
|
||||
CATEGORY_NOT_LINEBREAK: CATEGORY_NOT_LINEBREAK
|
||||
}
|
||||
|
||||
CH_UNICODE = {
|
||||
CATEGORY_DIGIT: CATEGORY_UNI_DIGIT,
|
||||
CATEGORY_NOT_DIGIT: CATEGORY_UNI_NOT_DIGIT,
|
||||
CATEGORY_SPACE: CATEGORY_UNI_SPACE,
|
||||
CATEGORY_NOT_SPACE: CATEGORY_UNI_NOT_SPACE,
|
||||
CATEGORY_WORD: CATEGORY_UNI_WORD,
|
||||
CATEGORY_NOT_WORD: CATEGORY_UNI_NOT_WORD,
|
||||
CATEGORY_LINEBREAK: CATEGORY_UNI_LINEBREAK,
|
||||
CATEGORY_NOT_LINEBREAK: CATEGORY_UNI_NOT_LINEBREAK
|
||||
}
|
||||
|
||||
# flags
|
||||
SRE_FLAG_IGNORECASE = 2 # case insensitive
|
||||
SRE_FLAG_LOCALE = 4 # honour system locale
|
||||
SRE_FLAG_MULTILINE = 8 # treat target as multiline string
|
||||
SRE_FLAG_DOTALL = 16 # treat target as a single string
|
||||
SRE_FLAG_UNICODE = 32 # use unicode "locale"
|
||||
SRE_FLAG_VERBOSE = 64 # ignore whitespace and comments
|
||||
SRE_FLAG_DEBUG = 128 # debugging
|
||||
SRE_FLAG_ASCII = 256 # use ascii "locale"
|
||||
|
||||
# flags for INFO primitive
|
||||
SRE_INFO_PREFIX = 1 # has prefix
|
||||
SRE_INFO_LITERAL = 2 # entire pattern is literal (given by prefix)
|
||||
SRE_INFO_CHARSET = 4 # pattern starts with character from given set
|
1081
Dependencies/Python/Lib/re/_parser.py
vendored
Normal file
1081
Dependencies/Python/Lib/re/_parser.py
vendored
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user