Instance Constructors

1.  new ParsingRun(input: ParserInput, startIndex: Int, originalParser: (ParsingRun[_]) ⇒ ParsingRun[_], traceIndex: Int, instrument: Instrument, failureTerminalAggregate: Msgs, failureGroupAggregate: Msgs, shortParserMsg: Msgs, lastFailureMsg: Msgs, failureStack: List[(String, Int)], isSuccess: Boolean, logDepth: Int, index: Int, cut: Boolean, successValue: Any, verboseFailures: Boolean, noDropBuffer: Boolean, misc: Map[Any, Any])
   input

   The input to the parsing run, as a ParserInput.

   startIndex

   Where the parse initially started, so as to allow .result.traced to re-create it with tracing enabled.

   originalParser

   The original parsing function we used to start this run, so as to allow .result.traced to re-create it with tracing enabled.

   traceIndex

   The index we wish to trace if tracing is enabled, else -1. Used to find failure messages to aggregate into failureTerminalAggregate

   instrument

   Callbacks that can be injected before/after every P(...) parser.

   failureTerminalAggregate

   When tracing is enabled, this collects up all the upper-most failures that happen at traceIndex (in Lazy wrappers) so they can be shown to the user at end-of-parse as suggestions for what could make the parse succeed. For terminal parsers like LiteralStr, it just aggregate's the string representation. For composite parsers like a ~ b or !a which may fail at traceIndex even without any of their wrapped terminal parsers failing there, it makes use of the shortParserMsg as the string representation of the composite parser.

   shortParserMsg

   When tracing is enabled, this contains string representation of the last parser to run. Since parsers aren't really objects, we piece together the string in the parser body and return store it here, and an enclosing parser may fetch it back out to help build its own string representation. If the last parser started before the traceIndex, we only aggregate the portion of the parser msg that takes place after traceIndex

   failureStack

   The stack of named P(...) parsers in effect when the failure occured; only constructed when tracing is enabled via traceIndex != -1

   isSuccess

   Whether or not the parse is currently successful

   logDepth

   How many nested .log calls are currently surrounding us. Used to nicely indent the log output so you can see which parsers are nested within which other parsers; -1 means logging is disabled

   index

   The current index of the parse

   cut

   Has the current parse been prevented from backtracking? This field starts as true at top-level, since there is nowhere to backtrack to. Upon entering a parser that can backtrack, such as | or .? or .rep, it is set to false, and re-set to true upon encountering a ./ or ~/ cut operator that prevents backtracking.

   successValue

   The currently returned success value

   verboseFailures

   Whether or not we are currently collecting lastFailureMsgs; defaults to false, unless traceIndex is set OR we are inside a LogByNameOps.log call which necessitates tracing in order to print out failure traces during logging

   noDropBuffer

   Flag that prevents the parser from dropping earlier input. Used for the .! capture operator that needs the input around to return as a string, the NoCut operator that forces backtracking (regardless of internal cuts), or whitespace consumption which implicitly backtracks if the parser on the RHS of the whitespace fails or consumes 0 characters. The value for this field is lexically scoped, but it is up to the individual parser method implementations to set the values and remember to un-set it to the previous value after they finish. Forgetting to re-set it to the previous value can cause strange behavior or crashes.

   misc

   Additional key-value metadata that a user can attach to a parsing run, and manage however they like. Not as high performance as the built-in fields of ParsingRun, but perhaps sufficient to satisfy ad-hoc needs e.g. keeping track of indentation or other contextual information