org.parboiled.scala

Visibility

Public
All

Type Members

type BasicParseRunner [V] = BasicParseRunner[V]

Definition Classes
package
type CharRule = CharRule

Definition Classes
package
class Input extends AnyRef

Simple Input abstraction serving as the target of a number of implicit conversions defined in the org.
type ParseRunner [V] = ParseRunner[V]

Definition Classes
package
trait Parser extends AnyRef

The main Parser trait for scala parboiled parsers.
class ParsingResult [+V] extends AnyRef

The scala wrapper for the org.
type PopRule1 [-Z] = PopRule1[Z]

Definition Classes
package
type PopRule2 [-Y, -Z] = PopRule2[Y, Z]

Definition Classes
package
type PopRule3 [-X, -Y, -Z] = PopRule3[X, Y, Z]

Definition Classes
package
type RecoveringParseRunner [V] = RecoveringParseRunner[V]

Definition Classes
package
type ReductionRule1 [-Z, +R] = ReductionRule1[Z, R]

Definition Classes
package
type ReductionRule2 [-Y, -Z, +R] = ReductionRule2[Y, Z, R]

Definition Classes
package
type ReductionRule3 [-X, -Y, -Z, +R] = ReductionRule3[X, Y, Z, R]

Definition Classes
package
type ReportingParseRunner [V] = ReportingParseRunner[V]

Definition Classes
package
type Rule = Rule

Definition Classes
package
type Rule0 = Rule0

Definition Classes
package
type Rule1 [+A] = Rule1[A]

Definition Classes
package
type Rule2 [+A, +B] = Rule2[A, B]

Definition Classes
package
type Rule3 [+A, +B, +C] = Rule3[A, B, C]

Definition Classes
package
type Rule4 [+A, +B, +C, +D] = Rule4[A, B, C, D]

Definition Classes
package
type Rule5 [+A, +B, +C, +D, +E] = Rule5[A, B, C, D, E]

Definition Classes
package
type Rule6 [+A, +B, +C, +D, +E, +F] = Rule6[A, B, C, D, E, F]

Definition Classes
package
type Rule7 [+A, +B, +C, +D, +E, +F, +G] = Rule7[A, B, C, D, E, F, G]

Definition Classes
package
type RuleMethod = StackTraceElement

Definition Classes
package
class RuleOption extends AnyRef

Rule building expressions can take a number of options which are implemented as case objects derived from this class.
type TracingParseRunner [V] = TracingParseRunner[V]

Definition Classes
package
class WithContextAction1 [A, R] extends (A) ⇒ R
class WithContextAction2 [A, B, R] extends (A, B) ⇒ R
class WithContextAction3 [A, B, C, R] extends (A, B, C) ⇒ R
class WithContextAction4 [A, B, C, D, R] extends (A, B, C, D) ⇒ R
class WithContextAction5 [A, B, C, D, E, R] extends (A, B, C, D, E) ⇒ R
class WithContextAction6 [A, B, C, D, E, F, R] extends (A, B, C, D, E, F) ⇒ R
class WithContextAction7 [A, B, C, D, E, F, G, R] extends (A, B, C, D, E, F, G) ⇒ R

Value Members

def & (sub: Rule): Rule0

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

Definition Classes
package
lazy val ANY : Rule0

A rule that matches any single character except EOI.
A rule that matches any single character except EOI.

Definition Classes
package
val BasicParseRunner : org.parboiled.scala.parserunners.BasicParseRunner.type

Definition Classes
package
lazy val DEDENT : Rule0

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

Definition Classes
package
lazy val DROP : PopRule1[Any]

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

Definition Classes
package
lazy val DROP2 : PopRule2[Any, Any]

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

Definition Classes
package
lazy val DROP3 : PopRule3[Any, Any, Any]

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

Definition Classes
package
lazy val EMPTY : Rule0

A rule that always matches but consumes no input.
A rule that always matches but consumes no input.

Definition Classes
package
lazy val EOI : Rule0

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

Definition Classes
package
lazy val INDENT : Rule0

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

Definition Classes
package
object MemoMismatches extends RuleOption with Product with Serializable

Enables memoization of rule mismatches for consecutive rule applications at the same input location.
lazy val NOTHING : Rule0

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

Definition Classes
package
object ParsingResult extends AnyRef
val RecoveringParseRunner : org.parboiled.scala.parserunners.RecoveringParseRunner.type

Definition Classes
package
val ReportingParseRunner : org.parboiled.scala.parserunners.ReportingParseRunner.type

Definition Classes
package
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).
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).
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).
val TracingParseRunner : org.parboiled.scala.parserunners.TracingParseRunner.type

Definition Classes
package
implicit def charArray2Input (input: Array[Char]): Input

Attributes
implicit
Definition Classes
package
implicit def creator4PopRule1 [Z] (m: Matcher): PopRule1[Z]

Attributes
implicit
Definition Classes
package
implicit def creator4PopRule2 [Y, Z] (m: Matcher): PopRule2[Y, Z]

Attributes
implicit
Definition Classes
package
implicit def creator4PopRule3 [X, Y, Z] (m: Matcher): PopRule3[X, Y, Z]

Attributes
implicit
Definition Classes
package
implicit def creator4ReductionRule1 [Z, R] (m: Matcher): ReductionRule1[Z, R]

Attributes
implicit
Definition Classes
package
implicit def creator4ReductionRule2 [Y, Z, R] (m: Matcher): ReductionRule2[Y, Z, R]

Attributes
implicit
Definition Classes
package
implicit def creator4ReductionRule3 [X, Y, Z, R] (m: Matcher): ReductionRule3[X, Y, Z, R]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule0 (m: Matcher): Rule0

Attributes
implicit
Definition Classes
package
implicit def creator4Rule1 [A] (m: Matcher): Rule1[A]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule2 [A, B] (m: Matcher): Rule2[A, B]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule3 [A, B, C] (m: Matcher): Rule3[A, B, C]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule4 [A, B, C, D] (m: Matcher): Rule4[A, B, C, D]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule5 [A, B, C, D, E] (m: Matcher): Rule5[A, B, C, D, E]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule6 [A, B, C, D, E, F] (m: Matcher): Rule6[A, B, C, D, E, F]

Attributes
implicit
Definition Classes
package
implicit def creator4Rule7 [A, B, C, D, E, F, G] (m: Matcher): Rule7[A, B, C, D, E, F, G]

Attributes
implicit
Definition Classes
package
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.
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.

Definition Classes
package
implicit def inputStream2Input (input: InputStream)(implicit codec: Codec): Input

Attributes
implicit
Definition Classes
package
def make [A, U] (a: A)(f: (A) ⇒ U): A

Definition Classes
package
package parserunners
package rules
implicit def source2Input (input: Source): Input

Attributes
implicit
Definition Classes
package
implicit def string2Input (input: String): Input

Attributes
implicit
Definition Classes
package
package testing
implicit def toRunAction (f: (Context[Any]) ⇒ Unit): Rule0

Attributes
implicit
Definition Classes
package
implicit def toTestAction (f: (Context[Any]) ⇒ Boolean): Rule0

Attributes
implicit
Definition Classes
package
package utils

scala

package scala

Type Members

type BasicParseRunner [V] = BasicParseRunner[V]

type CharRule = CharRule

class Input extends AnyRef

type ParseRunner [V] = ParseRunner[V]

trait Parser extends AnyRef

class ParsingResult [+V] extends AnyRef

type PopRule1 [-Z] = PopRule1[Z]

type PopRule2 [-Y, -Z] = PopRule2[Y, Z]

type PopRule3 [-X, -Y, -Z] = PopRule3[X, Y, Z]

type RecoveringParseRunner [V] = RecoveringParseRunner[V]

type ReductionRule1 [-Z, +R] = ReductionRule1[Z, R]

type ReductionRule2 [-Y, -Z, +R] = ReductionRule2[Y, Z, R]

type ReductionRule3 [-X, -Y, -Z, +R] = ReductionRule3[X, Y, Z, R]

type ReportingParseRunner [V] = ReportingParseRunner[V]

type Rule = Rule

type Rule0 = Rule0

type Rule1 [+A] = Rule1[A]

type Rule2 [+A, +B] = Rule2[A, B]

type Rule3 [+A, +B, +C] = Rule3[A, B, C]

type Rule4 [+A, +B, +C, +D] = Rule4[A, B, C, D]

type Rule5 [+A, +B, +C, +D, +E] = Rule5[A, B, C, D, E]

type Rule6 [+A, +B, +C, +D, +E, +F] = Rule6[A, B, C, D, E, F]

type Rule7 [+A, +B, +C, +D, +E, +F, +G] = Rule7[A, B, C, D, E, F, G]

type RuleMethod = StackTraceElement

class RuleOption extends AnyRef

type TracingParseRunner [V] = TracingParseRunner[V]

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

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

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

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

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

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

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

Value Members

def & (sub: Rule): Rule0

lazy val ANY : Rule0

val BasicParseRunner : org.parboiled.scala.parserunners.BasicParseRunner.type

lazy val DEDENT : Rule0

lazy val DROP : PopRule1[Any]

lazy val DROP2 : PopRule2[Any, Any]

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

lazy val EMPTY : Rule0

lazy val EOI : Rule0

lazy val INDENT : Rule0

object MemoMismatches extends RuleOption with Product with Serializable

lazy val NOTHING : Rule0

object ParsingResult extends AnyRef

val RecoveringParseRunner : org.parboiled.scala.parserunners.RecoveringParseRunner.type

val ReportingParseRunner : org.parboiled.scala.parserunners.ReportingParseRunner.type

object SkipNode extends RuleOption with Product with Serializable

object SuppressNode extends RuleOption with Product with Serializable

object SuppressSubnodes extends RuleOption with Product with Serializable

val TracingParseRunner : org.parboiled.scala.parserunners.TracingParseRunner.type

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

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

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

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

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

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

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

implicit def creator4Rule0 (m: Matcher): Rule0

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

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

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

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

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

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

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

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

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

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

package parserunners

package rules

implicit def source2Input (input: Source): Input

implicit def string2Input (input: String): Input

package testing

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