|
def | __init__ (self, other=None) |
|
def | __lshift__ (self, other) |
|
def | __ilshift__ (self, other) |
|
def | leaveWhitespace (self) |
|
def | streamline (self) |
|
def | validate (self, validateTrace=[]) |
|
def | __str__ (self) |
|
def | copy (self) |
|
def | __init__ (self, expr, savelist=False) |
|
def | parseImpl (self, instring, loc, doActions=True) |
|
def | ignore (self, other) |
|
def | checkRecursion (self, parseElementList) |
|
def | setName (self, name) |
|
def | setResultsName (self, name, listAllMatches=False) |
|
def | setBreak (self, breakFlag=True) |
|
def | setParseAction (self, *fns, **kwargs) |
|
def | addParseAction (self, *fns, **kwargs) |
|
def | addCondition (self, *fns, **kwargs) |
|
def | setFailAction (self, fn) |
|
def | preParse (self, instring, loc) |
|
def | postParse (self, instring, loc, tokenlist) |
|
def | tryParse (self, instring, loc) |
|
def | canParseNext (self, instring, loc) |
|
def | parseString (self, instring, parseAll=False) |
|
def | scanString (self, instring, maxMatches=_MAX_INT, overlap=False) |
|
def | transformString (self, instring) |
|
def | searchString (self, instring, maxMatches=_MAX_INT) |
|
def | split (self, instring, maxsplit=_MAX_INT, includeSeparators=False) |
|
def | __add__ (self, other) |
|
def | __radd__ (self, other) |
|
def | __sub__ (self, other) |
|
def | __rsub__ (self, other) |
|
def | __mul__ (self, other) |
|
def | __rmul__ (self, other) |
|
def | __or__ (self, other) |
|
def | __ror__ (self, other) |
|
def | __xor__ (self, other) |
|
def | __rxor__ (self, other) |
|
def | __and__ (self, other) |
|
def | __rand__ (self, other) |
|
def | __invert__ (self) |
|
def | __call__ (self, name=None) |
|
def | suppress (self) |
|
def | setWhitespaceChars (self, chars) |
|
def | parseWithTabs (self) |
|
def | setDebugActions (self, startAction, successAction, exceptionAction) |
|
def | setDebug (self, flag=True) |
|
def | __repr__ (self) |
|
def | parseFile (self, file_or_filename, parseAll=False) |
|
def | __eq__ (self, other) |
|
def | __ne__ (self, other) |
|
def | __hash__ (self) |
|
def | __req__ (self, other) |
|
def | __rne__ (self, other) |
|
def | matches (self, testString, parseAll=True) |
|
def | runTests (self, tests, parseAll=True, comment='#', fullDump=True, printResults=True, failureTests=False) |
|
Forward declaration of an expression to be defined later -
used for recursive grammars, such as algebraic infix notation.
When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
Note: take care when assigning to C{Forward} not to overlook precedence of operators.
Specifically, '|' has a lower precedence than '<<', so that::
fwdExpr << a | b | c
will actually be evaluated as::
(fwdExpr << a) | b | c
thereby leaving b and c out as parseable alternatives. It is recommended that you
explicitly group the values inserted into the C{Forward}::
fwdExpr << (a | b | c)
Converting to use the '<<=' operator instead will avoid this problem.
See L{ParseResults.pprint} for an example of a recursive parser created using
C{Forward}.
Make a copy of this C{ParserElement}. Useful for defining different parse actions
for the same parsing pattern, using copies of the original parse element.
Example::
integer = Word(nums).setParseAction(lambda toks: int(toks[0]))
integerK = integer.copy().addParseAction(lambda toks: toks[0]*1024) + Suppress("K")
integerM = integer.copy().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
print(OneOrMore(integerK | integerM | integer).parseString("5K 100 640K 256M"))
prints::
[5120, 100, 655360, 268435456]
Equivalent form of C{expr.copy()} is just C{expr()}::
integerM = integer().addParseAction(lambda toks: toks[0]*1024*1024) + Suppress("M")
Reimplemented from ParserElement.