sre_parse Namespace Reference

Classes
class	Pattern
class	SubPattern
class	Tokenizer

Functions
def	isident
def	isdigit
def	isname
def	_class_escape
def	_escape
def	_parse_sub
def	_parse_sub_cond
def	_parse
def	parse
def	parse_template
def	expand_template

Variables
string	SPECIAL_CHARS = ".\\[{()*+?^$|"
string	REPEAT_CHARS = "*+?{"
tuple	DIGITS = set("0123456789")
tuple	OCTDIGITS = set("01234567")
tuple	HEXDIGITS = set("0123456789abcdefABCDEF")
tuple	WHITESPACE = set(" \t\n\r\v\f")
dictionary	ESCAPES
dictionary	CATEGORIES
dictionary	FLAGS
tuple	_PATTERNENDERS = set("|)")
tuple	_ASSERTCHARS = set("=!<")
tuple	_LOOKBEHINDASSERTCHARS = set("=!")
tuple	_REPEATCODES = set([MIN_REPEAT, MAX_REPEAT])
list	start = set[:]
	if sourcematch(":"): pass # handle character classes More...
tuple	this = sourceget()
tuple	code1 = _class_escape(source, this)
tuple	code2 = _class_escape(source, this)
list	lo = code1[1]
list	hi = code2[1]
tuple	here = source.tell()
tuple	min = int(lo)
tuple	max = int(hi)
list	item = subpattern[-1:]
int	group = 1
	name = None
	condgroup = None
tuple	char = sourceget()
tuple	gid = state.groupdict.get(name)
int	dir = 1
tuple	p = _parse_sub(source, state)
string	condname = ""
tuple	code = _escape(source, this, state)

Function Documentation

def sre_parse._class_escape (   source,   escape  )

private

def sre_parse._escape (   source,   escape,   state  )

private

def sre_parse._parse (   source,   state  )

private

def sre_parse._parse_sub (   source,   state,   nested = 1  )

private

def sre_parse._parse_sub_cond (   source,   state,   condgroup  )

private

def sre_parse.expand_template	(		template,
			match
	)

def sre_parse.isdigit

(

char

)

def sre_parse.isident

(

char

)

def sre_parse.isname

(

name

)

def sre_parse.parse	(		str,
			flags = 0,
			pattern = None
	)

def sre_parse.parse_template	(		source,
			pattern
	)

Variable Documentation

tuple sre_parse._ASSERTCHARS = set("=!<")

tuple sre_parse._LOOKBEHINDASSERTCHARS = set("=!")

tuple sre_parse._PATTERNENDERS = set("|)")

tuple sre_parse._REPEATCODES = set([MIN_REPEAT, MAX_REPEAT])

dictionary sre_parse.CATEGORIES

Initial value:

= {
    r"\A": (AT, AT_BEGINNING_STRING), # start of string
    r"\b": (AT, AT_BOUNDARY),
    r"\B": (AT, AT_NON_BOUNDARY),
    r"\d": (IN, [(CATEGORY, CATEGORY_DIGIT)]),
    r"\D": (IN, [(CATEGORY, CATEGORY_NOT_DIGIT)]),
    r"\s": (IN, [(CATEGORY, CATEGORY_SPACE)]),
    r"\S": (IN, [(CATEGORY, CATEGORY_NOT_SPACE)]),
    r"\w": (IN, [(CATEGORY, CATEGORY_WORD)]),
    r"\W": (IN, [(CATEGORY, CATEGORY_NOT_WORD)]),
    r"\Z": (AT, AT_END_STRING), # end of string
}

tuple sre_parse.char = sourceget()

tuple sre_parse.code = _escape(source, this, state)

list sre_parse.code1 = _class_escape(source, this)

tuple sre_parse.code2 = _class_escape(source, this)

tuple sre_parse.condgroup = None

sre_parse.condname = ""

tuple sre_parse.DIGITS = set("0123456789")

int sre_parse.dir = 1

dictionary sre_parse.ESCAPES

Initial value:

= {
    r"\a": (LITERAL, ord("\a")),
    r"\b": (LITERAL, ord("\b")),
    r"\f": (LITERAL, ord("\f")),
    r"\n": (LITERAL, ord("\n")),
    r"\r": (LITERAL, ord("\r")),
    r"\t": (LITERAL, ord("\t")),
    r"\v": (LITERAL, ord("\v")),
    r"\\": (LITERAL, ord("\\"))
}

dictionary sre_parse.FLAGS

Initial value:

= {
    # standard flags
    "i": SRE_FLAG_IGNORECASE,
    "L": SRE_FLAG_LOCALE,
    "m": SRE_FLAG_MULTILINE,
    "s": SRE_FLAG_DOTALL,
    "x": SRE_FLAG_VERBOSE,
    # extensions
    "t": SRE_FLAG_TEMPLATE,
    "u": SRE_FLAG_UNICODE,
}

tuple sre_parse.gid = state.groupdict.get(name)

tuple sre_parse.group = 1

tuple sre_parse.here = source.tell()

tuple sre_parse.HEXDIGITS = set("0123456789abcdefABCDEF")

tuple sre_parse.hi = code2[1]

sre_parse.item = subpattern[-1:]

tuple sre_parse.lo = code1[1]

tuple sre_parse.max = int(hi)

tuple sre_parse.min = int(lo)

string sre_parse.name = None

tuple sre_parse.OCTDIGITS = set("01234567")

tuple sre_parse.p = _parse_sub(source, state)

string sre_parse.REPEAT_CHARS = "*+?{"

string sre_parse.SPECIAL_CHARS = ".\\[{()*+?^$|"

list sre_parse.start = set[:]

if sourcematch(":"): pass # handle character classes

tuple sre_parse.this = sourceget()

tuple sre_parse.WHITESPACE = set(" \t\n\r\v\f")