Module pyparsing :: Class Forward

Class Forward

     object --+        
              |        
  ParserElement --+    
                  |    
ParseElementEnhance --+
                      |
                     Forward

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 ``Forward`` variable using the '<<' operator.

Note: take care when assigning to ``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 ``Forward``:

   fwdExpr << (a | b | c)

Converting to use the '<<=' operator instead will avoid this problem.

See :class:`ParseResults.pprint` for an example of a recursive parser created using ``Forward``.

Nested Classes

[hide private]

Inherited from ParserElement (private): _FifoCache, _UnboundedCache, _literalStringClass

Instance Methods

[hide private]

__init__(self, other=None)
x.__init__(...) initializes x; see help(type(x)) for signature

source code

__lshift__(self, other)

source code

__ilshift__(self, other)

source code

leaveWhitespace(self)
Disables the skipping of whitespace before matching the characters in the :class:`ParserElement`'s defined pattern.

source code

streamline(self)

source code

validate(self, validateTrace=None)
Check defined expressions for valid structure, check for infinite recursive definitions.

source code

__str__(self)
str(x)

source code

copy(self)
Make a copy of this :class:`ParserElement`.

source code

_setResultsName(self, name, listAllMatches=False)

source code

Inherited from ParseElementEnhance: checkRecursion, ignore, parseImpl

Inherited from ParserElement: __add__, __and__, __call__, __eq__, __getitem__, __hash__, __invert__, __iter__, __mul__, __ne__, __or__, __radd__, __rand__, __repr__, __req__, __rmul__, __rne__, __ror__, __rsub__, __rxor__, __sub__, __xor__, addCondition, addParseAction, canParseNext, matches, parseFile, parseString, parseWithTabs, postParse, preParse, runTests, scanString, searchString, setBreak, setDebug, setDebugActions, setFailAction, setName, setParseAction, setResultsName, setWhitespaceChars, split, suppress, transformString, tryParse

Inherited from ParserElement (private): _parse, _parseCache, _parseNoCache, _skipIgnorables

Inherited from object: __delattr__, __format__, __getattribute__, __new__, __reduce__, __reduce_ex__, __setattr__, __sizeof__, __subclasshook__

Static Methods

[hide private]

Inherited from ParserElement: enablePackrat, inlineLiteralsUsing, resetCache, setDefaultWhitespaceChars

Class Variables

[hide private]

Inherited from ParserElement: DEFAULT_WHITE_CHARS, packrat_cache, packrat_cache_lock, packrat_cache_stats, verbose_stacktrace

Inherited from ParserElement (private): _packratEnabled

Properties

[hide private]

Inherited from object: __class__

Method Details

[hide private]

init(self, other=None)
(Constructor)

source code

x.__init__(...) initializes x; see help(type(x)) for signature

Overrides: object.__init__: (inherited documentation)

leaveWhitespace(self)

source code

Disables the skipping of whitespace before matching the characters in the :class:`ParserElement`'s defined pattern. This is normally only used internally by the pyparsing module, but may be needed in some whitespace-sensitive grammars.

Overrides: ParserElement.leaveWhitespace: (inherited documentation)

streamline(self)

source code

Overrides: ParserElement.streamline

validate(self, validateTrace=None)

source code

Check defined expressions for valid structure, check for infinite recursive definitions.

Overrides: ParserElement.validate: (inherited documentation)

str(self)
(Informal representation operator)

source code

str(x)

Overrides: object.__str__: (inherited documentation)

copy(self)

source code

Make a copy of this :class:`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 ``expr.copy()`` is just ``expr()``:

   integerM = integer().addParseAction(lambda toks: toks[0] * 1024 * 1024) + Suppress("M")

Overrides: ParserElement.copy: (inherited documentation)

_setResultsName(self, name, listAllMatches=False)

source code

Overrides: ParserElement._setResultsName

Class Forward

__init__(self, other=None) (Constructor)

leaveWhitespace(self)

streamline(self)

validate(self, validateTrace=None)

__str__(self) (Informal representation operator)

copy(self)

_setResultsName(self, name, listAllMatches=False)

init(self, other=None)
(Constructor)

str(self)
(Informal representation operator)