simpleparse.objectgenerator
index
/home/mcfletch/pylive/simpleparse/objectgenerator.py

Object-oriented tag-table generator objects
 
The objectgenerator module is the core of the SimpleParse
system, the various element token classes defined here
implement transitions from EBNF-style abstractions into
the low-level (assembly-like) instructions to the
TextTools engine.
 
Each class within the module is a sub-class of ElementToken,
which provides a number of common facilities, the most
obvious of which is the permute method, which takes care of
the negative, optional, and repeating flags for the normal
case (with character ranges and literals being non-normal).

 
Modules
       
copy
simpleparse.stt.TextTools.mxTextTools.mxTextTools
string
time
types

 
Classes
       
ElementToken
ErrorOnFail
Group
FirstOfGroup
SequentialGroup
CILiteral
LibraryElement
Literal
Name
Prebuilt
_Range
Range

 
class CILiteral(SequentialGroup)
    Case-insensitive Literal values
 
The CILiteral is a sequence of literal and
character-range values, where each element is
positive and required.  Literal values are
composed of those characters which are not
upper-case/lower-case pairs, while the ranges
are all two-character ranges with the upper
and lower forms.
 
CILiterals in the SimpleParse EBNF grammar are defined like so:
        c"test", c"test"?, c"test"*, c"test"+
        -c"test", -c"test"?, -c"test"*, -c"test"+
 
Attributes:
        value -- a string storing the literal's value
 
Notes:
        Currently we don't support Unicode literals
 
        A CILiteral will be *much* slower than a
        regular literal or character range
 
 
Method resolution order:
CILiteral
SequentialGroup
Group
ElementToken

Methods defined here:
ciParse(self, value)
Break value into set of case-dependent groups...
toParser(self, generator=None, noReport=0)

Data and other attributes defined here:
value = ''

Methods inherited from Group:
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes inherited from Group:
children = ()
terminalValue = None

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class ElementToken
    Abstract base class for all ElementTokens
 
Common Attributes:
 
        negative -- the element token should match
                a character if the "base" definition
                would not match at the current position
        optional -- the element token will match even
                if the base definition would not match
                at the current position
        repeating -- if the element is successfully
                matched, attempt to match it again.
        lookahead -- if true, the scanning position
                of the engine will be reset after the
                element matches
        errorOnFail -- if true, the engine will call the
                object stored in errorOnFail as a text-
                matching object iff the element token fails
                to match.  This is used to signal
                SyntaxErrors.
                
Attributes only used for top-level Productions:
 
        report -- if true, the production's results
                will be added to the result tree
        expanded -- if true, the production's children's
                results will be added to the result tree
                but the production's own result will be ignored
 
  Methods defined here:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.
terminal(self, generator)
Determine if this element is terminal for the generator
toParser(self, generator, noReport=0)
Abstract interface for implementing the conversion to a text-tools table
 
generator -- an instance of generator.Generator
        which provides various facilities for discovering
        other productions.
noReport -- if true, we're being called recursively
        for a terminal grammar fragment where one of our
        parents has explicitly suppressed all reporting.
 
This method is called by the generator or by
another element-token's toParser method.

Data and other attributes defined here:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class ErrorOnFail(ElementToken)
    When called as a matching function, raises a SyntaxError
 
Attributes:
        expected -- list of strings describing expected productions
        production -- string name of the production that's failing to parse
        message -- overrides default message generation if non-null
 
 
(something,something)+!
(something,something)!
(something,something)+!"Unable to parse somethings in my production"
(something,something)!"Unable to parse somethings in my production"
 
if string -> give an explicit message (with optional % values)
else -> use a default string
 
  Methods defined here:
__call__(self, text, position, end)
Method called by mxTextTools iff the base production fails
copy(self)

Data and other attributes defined here:
expected = ''
message = ''
production = ''

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.
terminal(self, generator)
Determine if this element is terminal for the generator
toParser(self, generator, noReport=0)
Abstract interface for implementing the conversion to a text-tools table
 
generator -- an instance of generator.Generator
        which provides various facilities for discovering
        other productions.
noReport -- if true, we're being called recursively
        for a terminal grammar fragment where one of our
        parents has explicitly suppressed all reporting.
 
This method is called by the generator or by
another element-token's toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class FirstOfGroup(Group)
    Set of tokens that matches (and stops searching) with the first successful child
 
A FirstOf group attempts to match each child in turn,
declaring success with the first successful child,
or failure if none of the children match.
 
Within the simpleparsegrammar, the FirstOf group
is defined like so:
        ("a" / b / c / "d")
i.e. a series of slash-separated element token definitions.
 
 
Method resolution order:
FirstOfGroup
Group
ElementToken

Methods defined here:
toParser(self, generator=None, noReport=0)

Methods inherited from Group:
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes inherited from Group:
children = ()
terminalValue = None

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class Group(ElementToken)
    Abstract base class for all group element tokens
 
The primary feature of a group is that it has a set
of element tokens stored in the attribute "children".
 
  Methods defined here:
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes defined here:
children = ()
terminalValue = None

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.
toParser(self, generator, noReport=0)
Abstract interface for implementing the conversion to a text-tools table
 
generator -- an instance of generator.Generator
        which provides various facilities for discovering
        other productions.
noReport -- if true, we're being called recursively
        for a terminal grammar fragment where one of our
        parents has explicitly suppressed all reporting.
 
This method is called by the generator or by
another element-token's toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class LibraryElement(ElementToken)
    Holder for a prebuilt item with it's own generator
 
  Methods defined here:
toParser(self, generator=None, noReport=0)

Data and other attributes defined here:
generator = None
methodSource = None
production = ''

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class Literal(ElementToken)
    Literal string value to be matched
 
Literals are one of the most common elements within
any grammar.  The implementation tries to use the
most efficient mechanism available for matching/searching
for a literal value, so the Literal class does not
use the permute method, instead defining explicit
parsing methodologies for each flag and value combination
 
Literals in the SimpleParse EBNF grammar are defined like so:
        "test", "test"?, "test"*, "test"+
        -"test", -"test"?, -"test"*, -"test"+
 
Attributes:
        value -- a string storing the literal's value
 
Notes:
        Currently we don't support Unicode literals
        
See also:
        CILiteral -- case-insensitive Literal values
 
  Methods defined here:
baseToParser(self, generator=None)
Parser generation without considering flag settings
terminal(self, generator)
Determine if this element is terminal for the generator
toParser(self, generator=None, noReport=0)
Create the parser for the element token

Data and other attributes defined here:
value = ''

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class Name(ElementToken)
    Reference to another rule in the grammar
 
The Name element token allows you to reference another
production within the grammar.  There are three major
sub-categories of reference depending on both the Name
element token and the referenced table's values.
 
if the Name token's report attribute is false,
or the target table's report attribute is false,
or the Name token negative attribute is true,
        the Name reference will report nothing in the result tree
 
if the target's expand attribute is true, however,
        the Name reference will report the children
        of the target production without reporting the
        target production's results (SubTable match)
 
finally:
        if the target is not expanded and the Name token
        should report something, the generator object is
        asked to supply the tag object and flags for
        processing the results of the target.  See the
        generator.MethodSource documentation for details.
 
Notes:
        expanded and un-reported productions won't get any
        methodsource methods called when 
        they are finished, that's just how I decided to
        do it, not sure if there's some case where you'd
        want it.  As a result, it's possible to have a
        method getting called for one instance (where a
        name ref is reporting) and not for another (where
        the name ref isn't reporting).
 
  Methods defined here:
terminal(self, generator)
Determine if this element is terminal for the generator
toParser(self, generator, noReport=0)
Create the table for parsing a name-reference
 
Note that currently most of the "compression" optimisations
occur here.

Data and other attributes defined here:
report = 1
terminalValue = None
value = ''

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0

 
class Prebuilt(ElementToken)
    Holder for pre-built TextTools tag tables
 
You can pass in a Pre-built tag table when
creating your grammar, doing so creates
Prebuilt element tokens which can be referenced
by the other element tokens in your grammar.
 
  Methods defined here:
toParser(self, generator=None, noReport=0)

Data and other attributes defined here:
value = ()

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class Range(_Range)
    Range type which doesn't use the CharSet features in mx.TextTools
 
This is likely to be much slower than the CharSet version (below), and
is unable to handle unicode character sets.  However, it will work with
TextTools 2.0.3, which may be needed in some cases.
 
 
Method resolution order:
Range
_Range
ElementToken

Methods defined here:
baseToParser(self, generator=None)
Parser generation without considering flag settings
terminal(self, generator)
Determine if this element is terminal for the generator

Methods inherited from _Range:
toParser(self, generator=None, noReport=0)
Create the parser for the element token

Data and other attributes inherited from _Range:
requiresExpandedSet = 1
value = ''

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class SequentialGroup(Group)
    A sequence of element tokens which must match in a particular order
 
A sequential group must match each child in turn
and all children must be satisfied to consider the
group matched.
 
Within the simpleparsegrammar, the sequential group
is defined like so:
        ("a", b, c, "d")
i.e. a series of comma-separated element token definitions.
 
 
Method resolution order:
SequentialGroup
Group
ElementToken

Methods defined here:
toParser(self, generator=None, noReport=0)

Methods inherited from Group:
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes inherited from Group:
children = ()
terminalValue = None

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
class _Range(ElementToken)
    Range of character values where any one of the characters may match
 
The Range token allows you to define a set of characters
(using a mini-grammar) of which any one may match.  By using
the repetition flags, it is possible to easily create such
common structures as "names" and "numbers".  For example:
 
        name := [a-zA-Z]+
        number := [0-9.eE]+
 
(Note: those are not beautifully defined examples :) ).
 
The mini-grammar for the simpleparsegrammar is defined as follows:
 
        '[',CHARBRACE?,CHARDASH?, (CHARRANGE/CHARNOBRACE)*, CHARDASH?,']'
        
that is, if a literal ']' character is wanted, you must
define the character as the first item in the range.  A literal
'-' character must appear as the first character after any
literal ']' character (or the beginning of the range) or as the
last character in the range.
 
Note: The expansion from the mini-grammar occurs before the
Range token is created (the simpleparse grammar does the
expansion), so the value attribute of the token is actually
the expanded string of characters.
 
  Methods defined here:
toParser(self, generator=None, noReport=0)
Create the parser for the element token

Data and other attributes defined here:
requiresExpandedSet = 1
value = ''

Methods inherited from ElementToken:
__init__(self, **namedarguments)
Initialize the object with named attributes
 
This method simply takes the named attributes and
updates the object's dictionary with them
__repr__(self)
Return a readily recognisable version of ourself
permute(self, basetable)
Given a positive, required, non-repeating table, convert to appropriately configured table
 
This method applies generic logic for applying the
operational flags to a basic recipe for an element.
 
It is normally called from the elements-token's own
toParser method.
terminal(self, generator)
Determine if this element is terminal for the generator

Data and other attributes inherited from ElementToken:
errorOnFail = None
expanded = 0
lookahead = 0
negative = 0
optional = 0
repeating = 0
report = 1

 
Functions
       
BMS = TextSearch(...)
TextSearch(match[,translate=None,algorithm=default_algorithm])
 
Create a substring search object for the string match;
translate is an optional translate-string like the one used
in the module re.
CharSet(...)
CharSet(definition)
 
Create a character set matching object from the string
FS = TextSearch(...)
TextSearch(match[,translate=None,algorithm=default_algorithm])
 
Create a substring search object for the string match;
translate is an optional translate-string like the one used
in the module re.
FSType = TextSearch(...)
TextSearch(match[,translate=None,algorithm=default_algorithm])
 
Create a substring search object for the string match;
translate is an optional translate-string like the one used
in the module re.
TagTable(...)
TagTable(definition[,cachable=1])
TextSearch(...)
TextSearch(match[,translate=None,algorithm=default_algorithm])
 
Create a substring search object for the string match;
translate is an optional translate-string like the one used
in the module re.
UnicodeTagTable(...)
TagTable(definition[,cachable=1])
charsplit(...)
charsplit(text,char,start=0,stop=len(text))
 
Split text[start:stop] into substrings at char and
return the result as list of strings.
cmp(...)
cmp(a,b)
 
Compare two valid taglist tuples w/r to their slice
position; this is useful for sorting joinlists.
compositeFlags(first, second, report=1)
Composite flags from two items into overall flag-set
copyToNewFlags(target, flags)
Copy target using combined flags
extractFlags(item, report=1)
Extract the flags from an item as a tuple
hex2str(...)
hex2str(text)
 
Return text interpreted as two byte HEX values converted
to a string.
isascii(...)
isascii(text,start=0,stop=len(text))
 
Return 1/0 depending on whether text only contains ASCII
characters.
join(...)
join(joinlist,sep='',start=0,stop=len(joinlist))
 
Copy snippets from different strings together producing a
new string
The first argument must be a list of tuples or strings;
tuples must be of the form (string,l,r[,...]) and turn out
as string[l:r]
NOTE: the syntax used for negative slices is different
than the Python standard: -1 corresponds to the first
character *after* the string, e.g. ('Example',0,-1) gives
'Example' and not 'Exampl', like in Python
sep is an optional separator string, start and stop
define the slice of joinlist that is taken into accont.
joinlist(...)
joinlist(text,list,start=0,stop=len(text))
 
Takes a list of tuples (replacement,l,r,...) and produces
a taglist suitable for join() which creates a copy
of text where every slice [l:r] is replaced by the
given replacement
- the list must be sorted using cmp() as compare function
- it may not contain overlapping slices
- the slices may not contain negative indices
- if the taglist cannot contain overlapping slices, you can
  give this function the taglist produced by tag() directly
  (sorting is not needed, as the list will already be sorted)
- start and stop set the slice to work in, i.e. text[start:stop]
lower(...)
lower(text)
 
Return text converted to lower case.
prefix(...)
prefix(text,prefixes,start=0,stop=len(text)[,translate])
 
Looks at text[start:stop] and returns the first matching
prefix out of the tuple of strings given in prefixes.
If no prefix is found to be matching, None is returned.
The optional 256 char translate string is used to translate
the text prior to comparing it with the given suffixes.
set(...)
set(string,logic=1)
 
Returns a character set for string: a bit encoded version
of the characters occurring in string.
- logic can be set to 0 if all characters *not* in string
  should go into the set
setfind(...)
setfind(text,set,start=0,stop=len(text))
 
Find the first occurence of any character from set in
text[start:stop]
 set must be a string obtained with set()
DEPRECATED: use CharSet().search() instead.
setsplit(...)
setsplit(text,set,start=0,stop=len(text))
 
Split text[start:stop] into substrings using set,
omitting the splitting parts and empty substrings.
set must be a string obtained from set()
DEPRECATED: use CharSet().split() instead.
setsplitx(...)
setsplitx(text,set,start=0,stop=len(text))
 
Split text[start:stop] into substrings using set, so
that every second entry consists only of characters in set.
set must be a string obtained with set()
DEPRECATED: use CharSet().splitx() instead.
setstrip(...)
setstrip(text,set,start=0,stop=len(text),mode=0)
 
Strip all characters in text[start:stop] appearing in set.
mode indicates where to strip (<0: left; =0: left and right;
>0: right). set must be a string obtained with set()
DEPRECATED: use CharSet().strip() instead.
splitat(...)
splitat(text,char,nth=1,start=0,stop=len(text))
 
Split text[start:stop] into two substrings at the nth
occurance of char and return the result as 2-tuple. If the
character is not found, the second string is empty. nth may
be negative: the search is then done from the right and the
first string is empty in case the character is not found.
str2hex(...)
str2hex(text)
 
Return text converted to a string consisting of two byte
HEX values.
suffix(...)
suffix(text,suffixes,start=0,stop=len(text)[,translate])
 
Looks at text[start:stop] and returns the first matching
suffix out of the tuple of strings given in suffixes.
If no suffix is found to be matching, None is returned.
The optional 256 char translate string is used to translate
the text prior to comparing it with the given suffixes.
tag(...)
tag(text,tagtable,sliceleft=0,sliceright=len(text),taglist=[],context=None) 
Produce a tag list for a string, given a tag-table
- returns a tuple (success, taglist, nextindex)
- if taglist == None, then no taglist is created
upper(...)
upper(text)
 
Return text converted to upper case.

 
Data
        A2Z = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
A2Z_charset = <Character Set object for 'A-Z' at 0x4a5a238>
A2Z_set = '\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
AllIn = 11
AllInCharSet = 41
AllInSet = 31
AllNotIn = 12
AppendMatch = 2048
AppendTagobj = 1024
AppendToTagobj = 512
BOYERMOORE = 0
Break = 0
Call = 201
CallArg = 202
CallTag = 256
EOF = 101
FASTSEARCH = 1
Fail = 100
Here = 1
Is = 13
IsIn = 14
IsInCharSet = 42
IsInSet = 32
IsNot = 15
IsNotIn = 15
Jump = 100
JumpTarget = 104
LookAhead = 4096
Loop = 205
LoopControl = 206
MatchFail = -1000000
MatchOk = 1000000
Move = 103
NoWord = 211
Reset = -1
Skip = 102
SubTable = 207
SubTableInList = 208
TRIVIAL = 2
Table = 203
TableInList = 204
ThisTable = 999
To = 0
ToBOF = 0
ToEOF = -1
Umlaute = '\xc4\xd6\xdc'
Umlaute_charset = <Character Set object for '\xc4\xd6\xdc' at 0x4a5a288>
Word = 21
WordEnd = 23
WordStart = 22
__file__ = '/home/mcfletch/pylive/simpleparse/objectgenerator.pyc'
__name__ = 'simpleparse.objectgenerator'
__package__ = 'simpleparse'
a2z = 'abcdefghijklmnopqrstuvwxyz'
a2z_charset = <Character Set object for 'a-z' at 0x4a5a210>
a2z_set = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
alpha_charset = <Character Set object for 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz' at 0x4a5a2b0>
alpha_set = '\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\x07\xfe\xff\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
alphanumeric = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
alphanumeric_charset = <Character Set object for 'ABCDEFGHIJKLMNOPQRSTU...cdefghijklmnopqrstuvwxyz0123456789' at 0x4a5a328>
alphanumeric_set = '\x00\x00\x00\x00\x00\x00\xff\x03\xfe\xff\xff\x07\xfe\xff\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
any = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./...\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
any_charset = <Character Set object for '\x00-\xff' at 0x4a5a418>
any_set = '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
formfeed = '\x0c'
formfeed_charset = <Character Set object for '\x0c' at 0x4a5a3a0>
german_alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\xe4\xf6\xfc\xdf\xc4\xd6\xdc'
german_alpha_charset = <Character Set object for 'ABCDEFGHIJKLMNOPQRSTU...uvwxyz\xe4\xf6\xfc\xdf\xc4\xd6\xdc' at 0x4a5a2d8>
german_alpha_set = '\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\x07\xfe\xff\xff\x07\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00@\x90\x10\x00@\x10'
id2cmd = {-1000000: 'MatchFail', -1: 'ToEOF', 0: 'Fail/Jump', 1: 'Here', 11: 'AllIn', 12: 'AllNotIn', 13: 'Is', 14: 'IsIn', 15: 'IsNotIn', 21: 'Word', ...}
newline = '\r\n'
newline_charset = <Character Set object for '\r\n' at 0x4a5a378>
newline_set = '\x00$\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
nonwhitespace_charset = <Character Set object for '^ \t\x0b\r\n\x0c' at 0x4a5a3f0>
nonwhitespace_set = '\xff\xc1\xff\xff\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
number = '0123456789'
number_charset = <Character Set object for '0-9' at 0x4a5a300>
number_set = '\x00\x00\x00\x00\x00\x00\xff\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
sFindWord = 213
sWordEnd = 212
sWordStart = 211
tagtable_cache = {(103136504, 0): <String Tag Table object at 0x612fe88>, (103846256, 0): <String Tag Table object at 0x622de88>, (103846832, 0): <String Tag Table object at 0x622d718>, (103847840, 0): <String Tag Table object at 0x65188b0>, (103847984, 0): <String Tag Table object at 0x6267a48>, (103848056, 0): <String Tag Table object at 0x61a1e00>, (103849064, 0): <String Tag Table object at 0x622dcf0>, (104413592, 0): <String Tag Table object at 0x622dbe0>, (104413808, 0): <String Tag Table object at 0x622d828>, (104971800, 0): <String Tag Table object at 0x622dd78>, ...}
to_lower = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./...\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
to_upper = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./...\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
umlaute = '\xe4\xf6\xfc\xdf'
umlaute_charset = <Character Set object for '\xe4\xf6\xfc\xdf' at 0x4a5a260>
white = ' \t\x0b'
white_charset = <Character Set object for ' \t\x0b' at 0x4a5a350>
white_set = '\x00\x02\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
whitespace = ' \t\x0b\r\n\x0c'
whitespace_charset = <Character Set object for ' \t\x0b\r\n\x0c' at 0x4a5a3c8>
whitespace_set = '\x00&\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'