Python: module simpleparse.objectgenerator

simpleparse.objectgenerator | index s:\sp\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 mx.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 non-method functions defined here: __doc__ = 'Case-insensitive Literal values\n\n\tThe CILiteral ...wer than a\n\t\tregular literal or character range\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` value = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` Methods inherited from Group: terminal(self, generator) `Determine if this element is terminal for the generator` Data and non-method functions inherited from Group: children = () `tuple() -> an empty tuple tuple(sequence) -> tuple initialized from sequence's items If the argument is a tuple, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = "Abstract base class for all ElementTokens\n\n\tComm...but the production's own result will be ignored\n\t" `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = 'When called as a matching function, raises a Syn...ional % values)\n\telse -> use a default string\n\t\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` expected = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` message = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` production = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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) Data and non-method functions defined here: __doc__ = 'Set of tokens that matches (and stops searching)...s of slash-separated element token definitions.\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` Methods inherited from Group: terminal(self, generator) `Determine if this element is terminal for the generator` Data and non-method functions inherited from Group: children = () `tuple() -> an empty tuple tuple(sequence) -> tuple initialized from sequence's items If the argument is a tuple, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = 'Abstract base class for all group element tokens...ment tokens stored in the attribute "children".\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` children = () `tuple() -> an empty tuple tuple(sequence) -> tuple initialized from sequence's items If the argument is a tuple, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
class LibraryElement(ElementToken)
`` | `Holder for a prebuilt item with it's own generator`
| Methods defined here: toParser(self, generator=None, noReport=0) Data and non-method functions defined here: __doc__ = "Holder for a prebuilt item with it's own generator" `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` generator = None methodSource = None production = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = 'Literal string value to be matched\n\n\tLiterals ar...\n\t\tCILiteral -- case-insensitive Literal values\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` value = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = "Reference to another rule in the grammar\n\n\tThe N...another (where\n\t\tthe name ref isn't reporting).\n\t" `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` terminalValue = None value = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = 'Holder for pre-built TextTools tag tables\n\n\tYou ...d\n\tby the other element tokens in your grammar.\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` value = () `tuple() -> an empty tuple tuple(sequence) -> tuple initialized from sequence's items If the argument is a tuple, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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` Data and non-method functions defined here: __doc__ = "Range type which doesn't use the CharSet feature...Tools 2.0.3, which may be needed in some cases.\n\t" `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` Methods inherited from _Range: toParser(self, generator=None, noReport=0) `Create the parser for the element token` Data and non-method functions inherited from _Range: requiresExpandedSet = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` value = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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) Data and non-method functions defined here: __doc__ = 'A sequence of element tokens which must match in...s of comma-separated element token definitions.\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` Methods inherited from Group: terminal(self, generator) `Determine if this element is terminal for the generator` Data and non-method functions inherited from Group: children = () `tuple() -> an empty tuple tuple(sequence) -> tuple initialized from sequence's items If the argument is a tuple, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`
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 non-method functions defined here: __doc__ = 'Range of character values where any one of the c...is actually\n\tthe expanded string of characters.\n\t' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` __module__ = 'simpleparse.objectgenerator' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` requiresExpandedSet = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` value = '' `str(object) -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.` 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 non-method functions inherited from ElementToken: errorOnFail = None expanded = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` lookahead = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` negative = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` optional = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` repeating = 0 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.` report = 1 `int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string.`

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 0xb07958> 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 0xb07b48> Word = 21 WordEnd = 23 WordStart = 22 __file__ = r'S:\sp\simpleparse\objectgenerator.pyc' __name__ = 'simpleparse.objectgenerator' a2z = 'abcdefghijklmnopqrstuvwxyz' a2z_charset = <Character Set object for 'a-z' at 0xb07870> 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 0xb07ce8> 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...bcdefghijklmnopqrstuvwxyz0123456789' at 0xae7198> 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 0x7aa898> 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 0xaac5a0> german_alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\xe4\xf6\xfc\xdf\xc4\xd6\xdc' german_alpha_charset = <Character Set object for 'ABCDEFGHIJKLMNOPQRSTU...tuvwxyz\xe4\xf6\xfc\xdf\xc4\xd6\xdc' at 0xb07e50> 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 0xae7430> 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 0xaac690> 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 0xb07ed8> 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 = {} 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 0xb07a50> white = ' \t\x0b' white_charset = <Character Set object for ' \t\x0b' at 0xae72c0> 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 0xaac5f0> 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'