org.parboiled2

Parser

abstract class Parser extends RuleDSL

Linear Supertypes
RuleDSL, RuleDSLActions, RuleDSLCombinators, RuleDSLBasics, AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Parser
  2. RuleDSL
  3. RuleDSLActions
  4. RuleDSLCombinators
  5. RuleDSLBasics
  6. AnyRef
  7. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Parser(initialValueStackSize: Int = 16, maxValueStackSize: Int = 1024)

Type Members

  1. sealed trait ActionOperator[I <: HList, O <: HList, Ops] extends AnyRef

    Definition Classes
    RuleDSLActions

  2. sealed trait CharRangeSupport extends AnyRef

    Definition Classes
    RuleDSLBasics

  3. sealed trait NTimes extends AnyRef

    Definition Classes
    RuleDSLCombinators

  4. trait Repeated extends AnyRef

    Definition Classes
    RuleDSLCombinators

  5. trait WithSeparatedBy[I <: HList, O <: HList] extends AnyRef

    Definition Classes
    RuleDSLCombinators

  6. class __SubParserInput extends ParserInput

    Attributes
    protected

Abstract Value Members

  1. abstract def input: ParserInput

    The input this parser instance is running against.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Definition Classes
    AnyRef → Any

  3. def &(r: Rule[_, _]): Rule0

    Runs its inner rule but resets the parser (cursor and value stack) afterwards, succeeds only if its inner rule succeeded.

    Runs its inner rule but resets the parser (cursor and value stack) afterwards, succeeds only if its inner rule succeeded.

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  4. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  5. def ANY: Rule0

    Matches any character except EOI.

    Matches any character except EOI.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  6. def EOI: Char

    Matches the EOI (end-of-input) character.

    Matches the EOI (end-of-input) character.

    Definition Classes
    RuleDSLBasics

  7. def MATCH: Rule0

    Matches no character (i.

    Matches no character (i.e. doesn't cause the parser to make any progress) but succeeds always (as a rule).

    Definition Classes
    RuleDSLBasics

  8. def MISMATCH[I <: HList, O <: HList]: Rule[I, O]

    A rule that always fails.

    A rule that always fails.

    Definition Classes
    RuleDSLBasics

  9. def MISMATCH0: Rule0

    Definition Classes
    RuleDSLBasics

  10. def __advance(): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  11. def __collectingErrors: Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  12. def __enterNotPredicate: Int

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  13. def __exitNotPredicate(saved: Int): Unit

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  14. final def __matchAnyOf(string: String, ix: Int = 0): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

    Annotations
    @tailrec()

  15. final def __matchIgnoreCaseString(string: String, ix: Int = 0): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

    Annotations
    @tailrec()

  16. final def __matchIgnoreCaseStringWrapped(string: String, ruleName: String, ix: Int = 0): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

    Annotations
    @tailrec()

  17. def __matchMap(m: Map[String, Any]): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  18. def __matchMapWrapped(m: Map[String, Any], ruleName: String): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  19. final def __matchNoneOf(string: String, ix: Int = 0): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

    Annotations
    @tailrec()

  20. final def __matchString(string: String, ix: Int = 0): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

    Annotations
    @tailrec()

  21. final def __matchStringWrapped(string: String, ruleName: String, ix: Int = 0): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

    Annotations
    @tailrec()

  22. def __push(value: Any): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  23. def __registerMismatch(): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  24. def __restoreState(mark: Mark): Unit

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  25. def __run[L <: HList](rule: ⇒ RuleN[L])(implicit scheme: DeliveryScheme[L]): Result

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  26. def __saveState: Mark

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  27. def __updateMaxCursor(): Boolean

    THIS IS NOT PUBLIC API and might become hidden in future.

    THIS IS NOT PUBLIC API and might become hidden in future. Use only if you know what you are doing!

  28. def anyOf(chars: String): Rule0

    Matches any single one of the given characters.

    Matches any single one of the given characters.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  29. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  30. def capture[I <: HList, O <: HList](r: Rule[I, O])(implicit p: Prepend[O, ::[String, HNil]]): Rule[I, Out]

    Pushes the input text matched by its inner rule onto the value stack after its inner rule has been run successfully (and only then).

    Pushes the input text matched by its inner rule onto the value stack after its inner rule has been run successfully (and only then).

    Definition Classes
    RuleDSLActions
    Annotations
    @compileTimeOnly( ... )

  31. implicit def ch(c: Char): Rule0

    Matches the given single character.

    Matches the given single character.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  32. implicit def charAndValue[T](t: (Char, T))(implicit h: HListable[T]): RuleN[Out]

    Matches a character and pushes the associated value.

    Matches a character and pushes the associated value.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  33. def charAt(offset: Int): Char

    Returns the character at the input index with the given delta to the cursor.

    Returns the character at the input index with the given delta to the cursor. Note: for performance optimization this method does *not* do a range check, i.e. depending on the ParserInput implementation you might get an exception when calling this method before any character was matched by the parser.

  34. def charAtRC(offset: Int): Char

    Same as charAt but range-checked.

    Same as charAt but range-checked. Returns the input character at the index with the given offset from the cursor. If this index is out of range the method returns EOI.

  35. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  36. def copyStateFrom(other: Parser, offset: Int): Unit

  37. def cursor: Int

    The index of the next (yet unmatched) input character.

    The index of the next (yet unmatched) input character. Might be equal to input.length!

  38. def cursorChar: Char

    The next (yet unmatched) input character, i.

    The next (yet unmatched) input character, i.e. the one at the cursor index. Identical to if (cursor < input.length) input.charAt(cursor) else EOI but more efficient.

  39. def drop[T](implicit h: HListable[T]): PopRule[Out]

    Drops one or more values from the top of the value stack.

    Drops one or more values from the top of the value stack. E.g. drop[Int] will drop the top Int value and drop[Int :: String :: HNil] will drop the top two values, which must be an Int underneath a String (the string being the top stack element).

    Definition Classes
    RuleDSLActions
    Annotations
    @compileTimeOnly( ... )

  40. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  41. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  42. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  43. def formatError(error: ParseError, showExpected: Boolean = true, showPosition: Boolean = true, showLine: Boolean = true, showTraces: Boolean = false): String

    Pretty prints the given ParseError instance in the context of the ParserInput of this parser.

  44. def formatErrorLine(error: ParseError): String

    Pretty prints the input line in which the error occurred and underlines the error position in the line with a caret.

  45. def formatErrorProblem(error: ParseError): String

    Pretty prints the input line in which the error occurred and underlines the error position in the line with a caret.

  46. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  47. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  48. def ignoreCase(s: String): Rule0

    Matches the given string of characters case insensitively.

    Matches the given string of characters case insensitively. Note: the given string must be specified in all lower-case! This requirement is currently NOT enforced!

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  49. def ignoreCase(c: Char): Rule0

    Matches the given single character case insensitively.

    Matches the given single character case insensitively. Note: the given character must be specified in lower-case! This requirement is currently NOT enforced!

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  50. implicit def int2NTimes(i: Int): NTimes

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  51. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  52. def lastChar: Char

    Returns the last character that was matched, i.

    Returns the last character that was matched, i.e. the one at index cursor - 1 Note: for performance optimization this method does *not* do a range check, i.e. depending on the ParserInput implementation you might get an exception when calling this method before any character was matched by the parser.

  53. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  54. def noneOf(chars: String): Rule0

    Matches any single character except the ones in the given string and except EOI.

    Matches any single character except the ones in the given string and except EOI.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  55. final def notify(): Unit

    Definition Classes
    AnyRef

  56. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  57. def oneOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit s: Lifter[Seq, I, O]): Rule[In, Out] with Repeated

    Runs its inner rule until it fails, succeeds if its inner rule succeeded at least once.

    Runs its inner rule until it fails, succeeds if its inner rule succeeded at least once. Resulting rule type is Rule0 if r == Rule0 Rule1[Seq[T]] if r == Rule1[T] Rule[I, O] if r == Rule[I, O <: I] // so called "reduction", which leaves the value stack unchanged on a type level

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  58. def optional[I <: HList, O <: HList](r: Rule[I, O])(implicit o: Lifter[Option, I, O]): Rule[In, Out]

    Runs its inner rule and succeeds even if the inner rule doesn't.

    Runs its inner rule and succeeds even if the inner rule doesn't. Resulting rule type is Rule0 if r == Rule0 Rule1[Option[T]] if r == Rule1[T] Rule[I, O] if r == Rule[I, O <: I] // so called "reduction", which leaves the value stack unchanged on a type level

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  59. implicit def predicate(p: CharPredicate): Rule0

    Matches any (single) character matched by the given CharPredicate.

    Matches any (single) character matched by the given CharPredicate.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  60. def push[T](value: T)(implicit h: HListable[T]): RuleN[Out]

    Pushes the given value onto the value stack.

    Pushes the given value onto the value stack. - if T is Unit nothing is pushed (i.e. push with a block/expression evaluating to Unit is identical to run) - if T <: HList all values of the HList is pushed as individual elements - otherwise a single value of type T is pushed.

    Definition Classes
    RuleDSLActions
    Annotations
    @compileTimeOnly( ... )

  61. implicit def range2NTimes(range: Range): NTimes

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  62. macro def rule[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

    Converts a compile-time only rule definition into the corresponding rule method implementation.

  63. implicit def rule2ActionOperator[I <: HList, O <: HList](r: Rule[I, O])(implicit ops: ActionOps[I, O]): ActionOperator[I, O, Out]

    Definition Classes
    RuleDSLActions
    Annotations
    @compileTimeOnly( ... )

  64. implicit def rule2WithSeparatedBy[I <: HList, O <: HList](r: Rule[I, O] with Repeated): WithSeparatedBy[I, O]

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  65. def run[T](arg: T)(implicit rr: RunResult[T]): Out

    Runs the given block / expression / action function.

    Runs the given block / expression / action function. A run rule can have several shapes, depending on its argument type. If the arg evaluates to

    - a rule (i.e. has type R <: Rule[_, _]) the result type of run is this rule's type (i.e. R) and the produced rule is immediately executed.

    - a function with 1 to 5 parameters these parameters are mapped against the top of the value stack, popped and the function executed. Thereby the function behaves just like an action function for the ~> operator, i.e. if it produces a Unit value this result is simply dropped. HList results are pushed onto the value stack (all their elements individually), rule results are immediately executed and other result values are pushed onto the value stack as a single element.

    - a function with one HList parameter the behavior is similar to the previous case with the difference that the elements of this parameter HList are mapped against the value stack top. This allows for consumption of an arbitrary number of value stack elements.

    - any other value the result type of run is an always succeeding Rule0.

    NOTE: Even though the block is not a call-by-name parameter it will be executed for every rule application anew! (Since the expression is directly transplanted into the rule method by the rule macro.

    Definition Classes
    RuleDSLActions
    Annotations
    @compileTimeOnly( ... )

  66. def runSubParser[I <: HList, O <: HList](f: (ParserInput) ⇒ Rule[I, O]): Rule[I, O]

    Allows creation of a sub parser and running of one of its rules as part of the current parsing process.

    Allows creation of a sub parser and running of one of its rules as part of the current parsing process. The subparser will start parsing at the current input position and the outer parser (this parser) will continue where the sub-parser stopped.

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

  67. implicit def str(s: String): Rule0

    Matches the given string of characters.

    Matches the given string of characters.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  68. implicit def str2CharRangeSupport(s: String): CharRangeSupport

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  69. implicit def stringAndValue[T](t: (String, T))(implicit h: HListable[T]): RuleN[Out]

    Matches a string and pushes the associated value.

    Matches a string and pushes the associated value.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  70. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef

  71. def test(condition: Boolean): Rule0

    Implements a semantic predicate.

    Implements a semantic predicate. If the argument expression evaluates to true the created rule matches otherwise it doesn't.

    Definition Classes
    RuleDSLActions
    Annotations
    @compileTimeOnly( ... )

  72. def toString(): String

    Definition Classes
    AnyRef → Any

  73. implicit def valueMap[T](m: Map[String, T])(implicit h: HListable[T]): RuleN[Out]

    Matches any of the given maps keys and pushes the respective value upon a successful match.

    Matches any of the given maps keys and pushes the respective value upon a successful match.

    Definition Classes
    RuleDSLBasics
    Annotations
    @compileTimeOnly( ... )

  74. def valueStack: ValueStack

    Allows "raw" (i.

    Allows "raw" (i.e. untyped) access to the ValueStack. In most cases you shouldn't need to access the value stack directly from your code. Use only if you know what you are doing!

  75. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  76. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  77. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  78. def zeroOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit s: Lifter[Seq, I, O]): Rule[In, Out] with Repeated

    Runs its inner rule until it fails, always succeeds.

    Runs its inner rule until it fails, always succeeds. Resulting rule type is Rule0 if r == Rule0 Rule1[Seq[T]] if r == Rule1[T] Rule[I, O] if r == Rule[I, O <: I] // so called "reduction", which leaves the value stack unchanged on a type level

    Definition Classes
    RuleDSLCombinators
    Annotations
    @compileTimeOnly( ... )

Inherited from RuleDSL

Inherited from RuleDSLActions

Inherited from RuleDSLCombinators

Inherited from RuleDSLBasics

Inherited from AnyRef

Inherited from Any

Ungrouped