org.parboiled

scala

package scala

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. scala
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. type BasicParseRunner[V] = scala.parserunners.BasicParseRunner[V]

  2. type CharRule = scala.rules.CharRule

  3. class Input extends AnyRef

    Simple Input abstraction serving as the target of a number of implicit conversions defined in the org.

  4. type ParseRunner[V] = scala.parserunners.ParseRunner[V]

  5. trait Parser extends AnyRef

    The main Parser trait for scala parboiled parsers.

  6. class ParsingResult[+V] extends AnyRef

    The scala wrapper for the org.

  7. type PopRule1[-Z] = scala.rules.PopRule1[Z]

  8. type PopRule2[-Y, -Z] = scala.rules.PopRule2[Y, Z]

  9. type PopRule3[-X, -Y, -Z] = scala.rules.PopRule3[X, Y, Z]

  10. type RecoveringParseRunner[V] = scala.parserunners.RecoveringParseRunner[V]

  11. type ReductionRule1[-Z, +R] = scala.rules.ReductionRule1[Z, R]

  12. type ReductionRule2[-Y, -Z, +R] = scala.rules.ReductionRule2[Y, Z, R]

  13. type ReductionRule3[-X, -Y, -Z, +R] = scala.rules.ReductionRule3[X, Y, Z, R]

  14. type ReportingParseRunner[V] = scala.parserunners.ReportingParseRunner[V]

  15. type Rule = scala.rules.Rule

  16. type Rule0 = scala.rules.Rule0

  17. type Rule1[+A] = scala.rules.Rule1[A]

  18. type Rule2[+A, +B] = scala.rules.Rule2[A, B]

  19. type Rule3[+A, +B, +C] = scala.rules.Rule3[A, B, C]

  20. type Rule4[+A, +B, +C, +D] = scala.rules.Rule4[A, B, C, D]

  21. type Rule5[+A, +B, +C, +D, +E] = scala.rules.Rule5[A, B, C, D, E]

  22. type Rule6[+A, +B, +C, +D, +E, +F] = scala.rules.Rule6[A, B, C, D, E, F]

  23. type Rule7[+A, +B, +C, +D, +E, +F, +G] = scala.rules.Rule7[A, B, C, D, E, F, G]

  24. type RuleMethod = StackTraceElement

  25. sealed abstract class RuleOption extends AnyRef

    Rule building expressions can take a number of options which are implemented as case objects derived from this class.

  26. type TracingParseRunner[V] = scala.parserunners.TracingParseRunner[V]

  27. class WithContextAction1[A, R] extends (A) ⇒ R

  28. class WithContextAction2[A, B, R] extends (A, B) ⇒ R

  29. class WithContextAction3[A, B, C, R] extends (A, B, C) ⇒ R

  30. class WithContextAction4[A, B, C, D, R] extends (A, B, C, D) ⇒ R

  31. class WithContextAction5[A, B, C, D, E, R] extends (A, B, C, D, E) ⇒ R

  32. class WithContextAction6[A, B, C, D, E, F, R] extends (A, B, C, D, E, F) ⇒ R

  33. class WithContextAction7[A, B, C, D, E, F, G, R] extends (A, B, C, D, E, F, G) ⇒ R

Value Members

  1. def &(sub: Rule): Rule0

    Creates an "AND" syntactic predicate according to the PEG formalism.

  2. lazy val ANY: Rule0

    A rule that matches any single character except EOI.

  3. val BasicParseRunner: scala.parserunners.BasicParseRunner.type

  4. lazy val DEDENT: Rule0

    A rule that matches the "DEDENT" non-character as produced by the IndentDedentInputBuffer.

  5. lazy val DROP: PopRule1[Any]

    A parser action removing the top element from the value stack.

  6. lazy val DROP2: PopRule2[Any, Any]

    A parser action removing the top two elements from the value stack.

  7. lazy val DROP3: PopRule3[Any, Any, Any]

    A parser action removing the top three elements from the value stack.

  8. lazy val EMPTY: Rule0

    A rule that always matches but consumes no input.

  9. lazy val EOI: Rule0

    A rule that matches the End-Of-Input non-character.

  10. lazy val INDENT: Rule0

    A rule that matches the "INDENT" non-character as produced by the IndentDedentInputBuffer.

  11. object MemoMismatches extends RuleOption with Product with Serializable

    Enables memoization of rule mismatches for consecutive rule applications at the same input location.

  12. lazy val NOTHING: Rule0

    A rule that never matches anything (i.

    A rule that never matches anything (i.e. that always fails).

  13. object ParsingResult

  14. val RecoveringParseRunner: scala.parserunners.RecoveringParseRunner.type

  15. val ReportingParseRunner: scala.parserunners.ReportingParseRunner.type

  16. object SkipNode extends RuleOption with Product with Serializable

    This rule option advises parboiled to not create a parse tree node for this rule (in case that parse tree building is enabled on the parser).

  17. object SuppressNode extends RuleOption with Product with Serializable

    This rule option advises parboiled to not create a parse tree node for this rule and all sub rules (in case that parse tree building is enabled on the parser).

  18. object SuppressSubnodes extends RuleOption with Product with Serializable

    This rule option advises parboiled to not create a parse tree node for the sub rules of this rule (in case that parse tree building is enabled on the parser).

  19. val TracingParseRunner: scala.parserunners.TracingParseRunner.type

  20. implicit def charArray2Input(input: Array[Char]): Input

  21. implicit def creator4PopRule1[Z](m: Matcher): PopRule1[Z]

  22. implicit def creator4PopRule2[Y, Z](m: Matcher): PopRule2[Y, Z]

  23. implicit def creator4PopRule3[X, Y, Z](m: Matcher): PopRule3[X, Y, Z]

  24. implicit def creator4ReductionRule1[Z, R](m: Matcher): ReductionRule1[Z, R]

  25. implicit def creator4ReductionRule2[Y, Z, R](m: Matcher): ReductionRule2[Y, Z, R]

  26. implicit def creator4ReductionRule3[X, Y, Z, R](m: Matcher): ReductionRule3[X, Y, Z, R]

  27. implicit def creator4Rule0(m: Matcher): Rule0

  28. implicit def creator4Rule1[A](m: Matcher): Rule1[A]

  29. implicit def creator4Rule2[A, B](m: Matcher): Rule2[A, B]

  30. implicit def creator4Rule3[A, B, C](m: Matcher): Rule3[A, B, C]

  31. implicit def creator4Rule4[A, B, C, D](m: Matcher): Rule4[A, B, C, D]

  32. implicit def creator4Rule5[A, B, C, D, E](m: Matcher): Rule5[A, B, C, D, E]

  33. implicit def creator4Rule6[A, B, C, D, E, F](m: Matcher): Rule6[A, B, C, D, E, F]

  34. implicit def creator4Rule7[A, B, C, D, E, F, G](m: Matcher): Rule7[A, B, C, D, E, F, G]

  35. def group[T <: Rule](rule: T): T

    Groups the given sub rule into one entity so that a following ~> operator receives the text matched by the whole group rather than only the immediately preceding sub rule.

  36. implicit def inputStream2Input(input: InputStream)(implicit codec: Codec): Input

  37. def make[A, U](a: A)(f: (A) ⇒ U): A

  38. package parserunners

  39. package rules

  40. implicit def source2Input(input: Source): Input

  41. implicit def string2Input(input: String): Input

  42. package testing

  43. implicit def toRunAction(f: (Context[Any]) ⇒ Unit): Rule0

  44. implicit def toTestAction(f: (Context[Any]) ⇒ Boolean): Rule0

  45. package utils

Inherited from AnyRef

Inherited from Any

Ungrouped