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
Visibility
  1. Public
  2. Protected

Package Members

  1. package parserunners
  2. package rules
  3. package utils

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.parboiled.scala package object.

  4. type ParseRunner[V] = scala.parserunners.ParseRunner[V]
  5. trait Parser extends AnyRef

    The main Parser trait for scala parboiled parsers.

    The main Parser trait for scala parboiled parsers. Defines the basic rule building methods as well as the caching and proxying logic.

  6. class ParsingResult[+V] extends AnyRef

    The scala wrapper for the org.parboiled.support.ParsingResult class.

  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, +A] = scala.rules.ReductionRule1[Z, A]
  12. type ReductionRule1_1[-Z, +A] = scala.rules.ReductionRule1[Z, A]
  13. type ReductionRule1_2[-Z, +A, +B] = scala.rules.ReductionRule1_2[Z, A, B]
  14. type ReductionRule1_3[-Z, +A, +B, +C] = scala.rules.ReductionRule1_3[Z, A, B, C]
  15. type ReductionRule1_4[-Z, +A, +B, +C, +D] = scala.rules.ReductionRule1_4[Z, A, B, C, D]
  16. type ReductionRule1_5[-Z, +A, +B, +C, +D, +E] = scala.rules.ReductionRule1_5[Z, A, B, C, D, E]
  17. type ReductionRule1_6[-Z, +A, +B, +C, +D, +E, +F] = scala.rules.ReductionRule1_6[Z, A, B, C, D, E, F]
  18. type ReductionRule1_7[-Z, +A, +B, +C, +D, +E, +F, +G] = scala.rules.ReductionRule1_7[Z, A, B, C, D, E, F, G]
  19. type ReductionRule2[-Y, -Z, +A] = scala.rules.ReductionRule2[Y, Z, A]
  20. type ReductionRule2_1[-Y, -Z, +A] = scala.rules.ReductionRule2[Y, Z, A]
  21. type ReductionRule2_2[-Y, -Z, +A, +B] = scala.rules.ReductionRule2_2[Y, Z, A, B]
  22. type ReductionRule2_3[-Y, -Z, +A, +B, +C] = scala.rules.ReductionRule2_3[Y, Z, A, B, C]
  23. type ReductionRule2_4[-Y, -Z, +A, +B, +C, +D] = scala.rules.ReductionRule2_4[Y, Z, A, B, C, D]
  24. type ReductionRule2_5[-Y, -Z, +A, +B, +C, +D, +E] = scala.rules.ReductionRule2_5[Y, Z, A, B, C, D, E]
  25. type ReductionRule2_6[-Y, -Z, +A, +B, +C, +D, +E, +F] = scala.rules.ReductionRule2_6[Y, Z, A, B, C, D, E, F]
  26. type ReductionRule2_7[-Y, -Z, +A, +B, +C, +D, +E, +F, +G] = scala.rules.ReductionRule2_7[Y, Z, A, B, C, D, E, F, G]
  27. type ReductionRule3[-X, -Y, -Z, +A] = scala.rules.ReductionRule3[X, Y, Z, A]
  28. type ReductionRule3_1[-X, -Y, -Z, +A] = scala.rules.ReductionRule3[X, Y, Z, A]
  29. type ReductionRule3_2[-X, -Y, -Z, +A, +B] = scala.rules.ReductionRule3_2[X, Y, Z, A, B]
  30. type ReductionRule3_3[-X, -Y, -Z, +A, +B, +C] = scala.rules.ReductionRule3_3[X, Y, Z, A, B, C]
  31. type ReductionRule3_4[-X, -Y, -Z, +A, +B, +C, +D] = scala.rules.ReductionRule3_4[X, Y, Z, A, B, C, D]
  32. type ReductionRule3_5[-X, -Y, -Z, +A, +B, +C, +D, +E] = scala.rules.ReductionRule3_5[X, Y, Z, A, B, C, D, E]
  33. type ReductionRule3_6[-X, -Y, -Z, +A, +B, +C, +D, +E, +F] = scala.rules.ReductionRule3_6[X, Y, Z, A, B, C, D, E, F]
  34. type ReductionRule3_7[-X, -Y, -Z, +A, +B, +C, +D, +E, +F, +G] = scala.rules.ReductionRule3_7[X, Y, Z, A, B, C, D, E, F, G]
  35. type ReportingParseRunner[V] = scala.parserunners.ReportingParseRunner[V]
  36. type Rule = scala.rules.Rule
  37. type Rule0 = scala.rules.Rule0
  38. type Rule1[+A] = scala.rules.Rule1[A]
  39. type Rule2[+A, +B] = scala.rules.Rule2[A, B]
  40. type Rule3[+A, +B, +C] = scala.rules.Rule3[A, B, C]
  41. type Rule4[+A, +B, +C, +D] = scala.rules.Rule4[A, B, C, D]
  42. type Rule5[+A, +B, +C, +D, +E] = scala.rules.Rule5[A, B, C, D, E]
  43. type Rule6[+A, +B, +C, +D, +E, +F] = scala.rules.Rule6[A, B, C, D, E, F]
  44. type Rule7[+A, +B, +C, +D, +E, +F, +G] = scala.rules.Rule7[A, B, C, D, E, F, G]
  45. type RuleMethod = StackTraceElement
  46. 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.

  47. type TracingParseRunner[V] = scala.parserunners.TracingParseRunner[V]
  48. class WithContextAction1[A, R] extends (A) => R
  49. class WithContextAction2[A, B, R] extends (A, B) => R
  50. class WithContextAction3[A, B, C, R] extends (A, B, C) => R
  51. class WithContextAction4[A, B, C, D, R] extends (A, B, C, D) => R
  52. class WithContextAction5[A, B, C, D, E, R] extends (A, B, C, D, E) => R
  53. class WithContextAction6[A, B, C, D, E, F, R] extends (A, B, C, D, E, F) => R
  54. 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. lazy val NOTHING: Rule0

    A rule that never matches anything (i.e.

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

  12. val RecoveringParseRunner: scala.parserunners.RecoveringParseRunner.type
  13. val ReportingParseRunner: scala.parserunners.ReportingParseRunner.type
  14. val TracingParseRunner: scala.parserunners.TracingParseRunner.type
  15. implicit def charArray2Input(input: Array[Char]): Input
  16. implicit def creator4PopRule1[Z](m: Matcher): PopRule1[Z]
  17. implicit def creator4PopRule2[Y, Z](m: Matcher): PopRule2[Y, Z]
  18. implicit def creator4PopRule3[X, Y, Z](m: Matcher): PopRule3[X, Y, Z]
  19. implicit def creator4ReductionRule1[Z, R](m: Matcher): ReductionRule1[Z, R]
  20. implicit def creator4ReductionRule2[Y, Z, R](m: Matcher): ReductionRule2[Y, Z, R]
  21. implicit def creator4ReductionRule3[X, Y, Z, R](m: Matcher): ReductionRule3[X, Y, Z, R]
  22. implicit def creator4Rule0(m: Matcher): Rule0
  23. implicit def creator4Rule1[A](m: Matcher): Rule1[A]
  24. implicit def creator4Rule2[A, B](m: Matcher): Rule2[A, B]
  25. implicit def creator4Rule3[A, B, C](m: Matcher): Rule3[A, B, C]
  26. implicit def creator4Rule4[A, B, C, D](m: Matcher): Rule4[A, B, C, D]
  27. implicit def creator4Rule5[A, B, C, D, E](m: Matcher): Rule5[A, B, C, D, E]
  28. implicit def creator4Rule6[A, B, C, D, E, F](m: Matcher): Rule6[A, B, C, D, E, F]
  29. implicit def creator4Rule7[A, B, C, D, E, F, G](m: Matcher): Rule7[A, B, C, D, E, F, G]
  30. 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.

  31. implicit def inputStream2Input(input: InputStream)(implicit codec: Codec): Input
  32. def make[A, U](a: A)(f: (A) => U): A
  33. implicit def source2Input(input: Source): Input
  34. implicit def string2Input(input: String): Input
  35. implicit def toRunAction(f: (Context[Any]) => Unit): Rule0
  36. implicit def toTestAction(f: (Context[Any]) => Boolean): Rule0
  37. case object MemoMismatches extends RuleOption with Product with Serializable

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

  38. object ParsingResult
  39. case 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).

  40. case 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).

  41. case 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).

Inherited from AnyRef

Inherited from Any

Ungrouped